Add remaining Network SDKStats short-interval signals

[JacksonWeber]

Follows up #145 by adding the remaining Network SDKStats short-interval metrics defined in the AppInsights SDKStats spec, aligned with the updated sdkstats.md (PRs #938 and #942).

New metrics

• Request_Failure_Count (endpoint, host, statusCode)
• Request_Duration (endpoint, host) - per-interval average
• Retry_Count (endpoint, host, statusCode)
• Throttle_Count (endpoint, host, statusCode)
• Exception_Count (endpoint, host, exceptionType)

Existing Request_Success_Count is unchanged.

A365 status code classification (Breeze HTTP semantics)

Per the spec, endpoint=�365 follows the same HTTP code set as endpoint=�reeze :

• success: 2xx except 206
• ignored: 206, 307, 308
• throttle: 402, 439
• retry: 401, 403, 408, 429, 500, 502, 503, 504
• failure: everything else

OTLP status code classification (OTLP/HTTP semantics)

The updated spec requires OTLP exporters report HTTP status codes per the OTLP/HTTP response section. The upstream @opentelemetry/otlp-exporter-base delegate exposes a status code on OTLPExporterError.code only for non-retryable failures; retryable HTTP responses (429/502/503/504) are collapsed into a synthetic message with the original code discarded. The wrapper classifies as follows:

• Numeric HTTP status (100-599) on the error -> Request_Failure_Count (or Retry_Count for 429/502/503/504 if the failure path still carries it).
• Synthetic "Export failed with retryable status" message -> Retry_Count with statusCode="unknown" (status is lost upstream; spec dimension preserved).
• AbortError / TimeoutError / "Request timed out" -> Exception_Count(exceptionType="Timeout exception").
• TypeError or Node socket errors (ECONNREFUSED/ENOTFOUND/...) -> Exception_Count(exceptionType="Network exception").
• Any other thrown error -> Exception_Count(exceptionType="Client exception").

Throttle (429 + Retry-After) is intentionally bucketed as retry rather than throttle because the upstream delegate does not surface response headers; over-counting throttle would distort customer panic signals.

Wiring

• A365 exporter: each retry attempt is timed; classifyStatusCode dispatches to the right recorder. Caught exceptions are bucketed (Timeout / Network / Client) mirroring the AzMon ExceptionType enum.
• OTLP wrapper: every export is timed and Request_Duration is recorded; failures are routed through the OTLP-aware classifier described above. Also adds forceFlush to NetworkStatsLogExporter so it conforms to the current LogRecordExporter interface.

Tests

• New unit coverage for each record function, duration averaging, classifyStatusCode buckets, A365 failure/retry/throttle/exception/duration paths, and the OTLP wrapper's failure / retry / retryable-loss / network / timeout / non-HTTP-code branches.
• Full unit suite: 849 passed / 5 todo / 0 failed. Lint and build clean.

[Copilot]

Pull request overview

This PR completes the SDKStats “Network” short-interval metric set by adding failure/retry/throttle/exception counters plus a per-interval average request duration metric, and wiring them into both the A365 exporter and the OTLP exporter wrappers.

Changes:

• Expanded sdkstats/networkStats with five new counters, a duration accumulator (sum/count → per-interval average on drain), and a shared classifyStatusCode helper.
• Updated A365 exporter and OTLP wrapper decorators to record the new signals (including per-attempt duration for A365 retries).
• Added/extended unit tests covering new recorders, duration averaging, status bucketing, and exporter wiring.

Reviewed changes

Copilot reviewed 9 out of 9 changed files in this pull request and generated 2 comments.

Show a summary per file

File	Description
src/sdkstats/networkStats.ts	Adds new network metric constants, counters, duration averaging, and HTTP status classification.
src/sdkstats/metrics.ts	Registers the additional observable gauges and maps variable-length keys to attributes via keyAttributes.
src/sdkstats/otlpWrapper.ts	Records duration for all exports and emits a stable Exception_Count label on non-success results.
src/sdkstats/index.ts	Re-exports the new metric names, recorders, and classifyStatusCode.
src/a365/exporter/Agent365Exporter.ts	Records duration + status/exception counters per request attempt; adds exception-type bucketing helper.
test/internal/unit/sdkstats/networkStats.test.ts	Adds unit tests for new recorders, duration averaging, and status bucketing.
test/internal/unit/sdkstats/metrics.test.ts	Validates OTel metric emission (attributes + avg duration) for the new signals.
test/internal/unit/sdkstats/otlpWrapper.test.ts	Verifies OTLP wrapper emits exception count + duration on FAILED and duration on SUCCESS.
test/internal/unit/a365/agent365NetworkStats.test.ts	Adds A365 exporter wiring tests for failure/retry/throttle/exception/duration metrics.

Comments suppressed due to low confidence (1)

src/sdkstats/otlpWrapper.ts:89

• wrapExport doesn't handle the case where the wrapped exporter throws synchronously (before invoking the callback). In that scenario the wrapper won't record Request_Duration / Exception_Count and the exception will escape to callers. Consider wrapping inner(settle) in a try/catch, recording duration/exception, and invoking resultCallback with a FAILED ExportResult (including the caught error) to keep wrapper behavior consistent with its docstring.

function wrapExport<T>(
  host: string,
  inner: (resultCallback: (result: ExportResult) => void) => void,
  resultCallback: (result: ExportResult) => void,
  _items: T,
): void {
  const start = Date.now();
  const settle = (result: ExportResult): void => {
    recordDuration(OTLP_ENDPOINT_CATEGORY, host, Date.now() - start);
    if (result.code === ExportResultCode.SUCCESS) {
      recordSuccess(OTLP_ENDPOINT_CATEGORY, host);
    } else {
      recordException(OTLP_ENDPOINT_CATEGORY, host, OTLP_FAILED_EXCEPTION_TYPE);
    }
    resultCallback(result);
  };

  inner(settle);
}

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[JacksonWeber]

Also addressed the suppressed-confidence finding about wrapExport not handling synchronous throws from the inner exporter (commit e2985a1):

• Wrapped inner(settle) in a try/catch.
• On a synchronous throw, the wrapper now records Request_Duration and Exception_Count(exceptionType=\"ExporterFailed\") and invokes resultCallback with { code: FAILED, error } so the exception never escapes to the caller.
• Added a settled guard so the success/failure path can't double-record if inner both throws and invokes the callback.
• New unit test in otlpWrapper.test.ts covers the synchronous-throw path end-to-end (asserts FAILED result, original error propagated, exception + duration recorded).

Full unit suite: 844 passed / 5 todo / 0 failed.

[rads-1996]

LGTM