@oxy.so/telemetry 2.0.0 → 2.2.0

package/dist/types/metrics.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Operational metrics for Oxy services, published as CloudWatch Embedded Metric
+ * Format (EMF) log lines.
+ *
+ * WHY EMF ON STDOUT: every Oxy backend runs on ECS with the `awslogs` driver, and
+ * CloudWatch Logs extracts metrics from any log event shaped as EMF — no agent,
+ * no sidecar, no scraper, no IAM grant beyond the logging the task already has.
+ * A registry that only an HTTP scrape can read (Prometheus) measures into a void
+ * when nothing scrapes it, which is how Mention's counters lost every value on
+ * every deploy.
+ *
+ * WHY AGGREGATED: values are folded in memory and flushed once per interval as
+ * ONE line per (metric, label set), not one line per observation. A latency is
+ * kept as a distribution (`Values`/`Counts`), so CloudWatch still answers
+ * SampleCount, p50 and p99 for it — the request COUNT is the distribution's
+ * SampleCount, so a service needs no separate counter for it.
+ *
+ * WHY MOST LABELS ARE NOT DIMENSIONS: every distinct combination of dimension
+ * values is a billed custom metric. Route x method as dimensions once measured
+ * 405 metrics and ~80 % of the account's CloudWatch bill (Mention #1334). So a
+ * label becomes a DIMENSION only when a metric definition names it in
+ * `dimensionSets`, and only labels with a small, closed value set belong there.
+ * Every other label is written as a plain property of the line: free to store,
+ * and grouped in Logs Insights (`stats sum(RequestLatency.Count) by Route`).
+ */
+export type MetricUnit = 'Count' | 'Milliseconds' | 'Seconds' | 'Bytes' | 'Percent' | 'Count/Second' | 'None';
+/**
+ * `sum` adds every value in the interval (a counter), `distribution` keeps the
+ * values for percentiles (a latency or a size), and `gauge` keeps the last one.
+ */
+export type MetricKind = 'sum' | 'distribution' | 'gauge';
+export interface MetricDefinition {
+    /** CloudWatch metric name; also the field holding its value on the line. */
+    readonly name: string;
+    readonly unit: MetricUnit;
+    readonly kind: MetricKind;
+    /**
+     * Label names promoted to CloudWatch dimensions. Each inner list is one
+     * dimension set, published IN ADDITION to the always-present `[Service]`
+     * set. Only closed, small value sets belong here: each distinct combination
+     * is a billed custom metric.
+     */
+    readonly dimensionSets?: readonly (readonly string[])[];
+}
+export type MetricLabels = Readonly<Record<string, string>>;
+export interface EmfPublisherOptions {
+    /** CloudWatch namespace, e.g. `Oxy/Api`. */
+    readonly namespace: string;
+    /** Value of the `Service` dimension every metric carries. */
+    readonly service: string;
+    /** Flush period. Default 60 s, CloudWatch's standard resolution. */
+    readonly flushIntervalMs?: number;
+    /**
+     * Distinct (metric, label set) series held per interval. A label value that
+     * traffic can mint must not be able to grow memory or log volume without
+     * bound, so past this many every NEW series is folded into one whose labels
+     * all read `other`. Default 2000.
+     */
+    readonly maxSeries?: number;
+    /** Where each line goes. Default: one line on stdout. */
+    readonly write?: (line: string) => void;
+    /** Clock, for tests. */
+    readonly now?: () => number;
+}
+export interface EmfPublisher {
+    /** Fold one observation into the current interval. Never throws. */
+    record(metric: MetricDefinition, value: number, labels?: MetricLabels): void;
+    /** Write the current interval now and start a new one. */
+    flush(): void;
+    /** Flush and stop the timer, for graceful shutdown. */
+    stop(): void;
+}
+/** One HTTP request: SampleCount is the request count, percentiles the latency. */
+export declare const HTTP_REQUEST_LATENCY: MetricDefinition;
+/** One request a rate limiter refused (429), per calling application. */
+export declare const HTTP_RATE_LIMITED: MetricDefinition;
+/** `2xx`, `4xx`, … — a closed set, safe as a dimension. */
+export declare function statusClass(status: number): string;
+/**
+ * `createEmfPublisher` on ECS, `null` everywhere else (a laptop, CI, a test):
+ * the gate oxy-api and Mention each repeated. `env` is injectable for tests.
+ */
+export declare function createEmfPublisherIfDeployed(options: EmfPublisherOptions, env?: Readonly<Record<string, string | undefined>>): EmfPublisher | null;
+export declare function createEmfPublisher(options: EmfPublisherOptions): EmfPublisher;

package/dist/types/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/types/server.d.ts

@@ -1,12 +1,18 @@
-import type { ActivityAggregate, AnonymousActivityMetadata } from './index.js';
+import { type ActivityAggregate, type AnonymousActivityMetadata } from './index.js';
 export declare const DEFAULT_PRESENCE_BUCKET_MS = 30000;
+/** @deprecated Unused by any Oxy repo; `presenceKeys` already encodes the window. Removal is planned for the next major. */
 export declare const DEFAULT_ACTIVE_CLIENT_WINDOW_MS = 60000;
 export type TelemetryHeaderValue = string | readonly string[] | undefined;
 export type TelemetryHeaders = Readonly<Record<string, TelemetryHeaderValue>>;
+/**
+ * @deprecated Unused by any Oxy repo (presence counting lives in the API). No
+ * replacement; removal is planned for the next major.
+ */
 export interface ActivityCardinalityAdapter {
     add(key: string, activityId: string, ttlSeconds: number): Promise<void>;
     count(keys: readonly string[]): Promise<number>;
 }
+/** @deprecated Unused by any Oxy repo; see `activityFlow`. */
 export interface ActivityFlow {
     sourceRegion?: string;
     service: string;
@@ -14,9 +20,28 @@ export interface ActivityFlow {
 }
 export declare function normalizeEdgePop(value: TelemetryHeaderValue): string | undefined;
 export declare function normalizeActivityId(value: TelemetryHeaderValue): string | undefined;
+/**
+ * The collector's source region for a normalised edge PoP (`edge-<pop>`), the
+ * one derivation every reporter shares. `undefined` when there is no PoP.
+ */
+export declare function sourceRegionFromEdgePop(edgePop: string | undefined): string | undefined;
 export declare function metadataFromHeaders(headers: TelemetryHeaders): AnonymousActivityMetadata;
+/**
+ * @deprecated Unused by any Oxy repo. For the bounded activity category of a
+ * path use `trafficType` from `@oxy.so/telemetry/collector`. Removal is planned
+ * for the next major.
+ */
 export declare function serviceFromPath(path: string): string;
+/**
+ * @deprecated Unused by any Oxy repo; `createTrafficCollector` keys its own
+ * flows. Removal is planned for the next major.
+ */
 export declare function activityFlow(sourceRegion: string | undefined, service: string): ActivityFlow;
+/**
+ * @deprecated Unused outside `presenceKeys`; call `presenceKeys` for the
+ * current and previous bucket keys. Removal is planned for the next major.
+ */
 export declare function presenceBucket(observedAt: number, bucketMs?: number): number;
 export declare function presenceKeys(sourceRegion: string, observedAt: number, bucketMs?: number): readonly [string, string];
+/** @deprecated Unused by any Oxy repo; use `ActivityAggregate` from `@oxy.so/telemetry`. */
 export type ActivityBucket = ActivityAggregate;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oxy.so/telemetry",
-  "version": "2.0.0",
-  "description": "Framework-agnostic anonymous activity telemetry primitives for Oxy services.",
+  "version": "2.2.0",
+  "description": "Framework-agnostic anonymous activity telemetry and CloudWatch EMF metrics primitives for Oxy services.",
   "type": "module",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -19,6 +19,9 @@
       ],
       "socket": [
         "dist/types/socket.d.ts"
+      ],
+      "metrics": [
+        "dist/types/metrics.d.ts"
       ]
     }
   },
@@ -88,12 +91,24 @@
         "types": "./dist/types/socket.d.ts",
         "default": "./dist/cjs/socket.js"
       }
+    },
+    "./metrics": {
+      "import": {
+        "types": "./dist/types/metrics.d.ts",
+        "default": "./dist/esm/metrics.js"
+      },
+      "require": {
+        "types": "./dist/types/metrics.d.ts",
+        "default": "./dist/cjs/metrics.js"
+      }
     }
   },
   "files": [
     "dist",
-    "src"
+    "src",
+    "!dist/.oxy-source-digest"
   ],
+  "oxySourceStamp": "dist",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/OxyHQ/oxy.git",
@@ -106,23 +121,22 @@
     "node": ">=18.0.0"
   },
   "scripts": {
-    "build": "bun run clean && bun run build:cjs && bun run build:esm && bun run build:types",
+    "build": "bun run clean && bun run build:cjs && bun run build:esm && bun run build:types && node -e \"const p='../app-preset/metro/source-stamp.js';require('node:fs').existsSync(p)&&require(p).writeStamp(process.cwd())\"",
     "build:cjs": "tsc -p tsconfig.cjs.json && node scripts/mark-cjs.mjs",
     "build:esm": "tsc -p tsconfig.esm.json",
-    "build:types": "tsc -p tsconfig.types.json",
+    "build:types": "tsc -p tsconfig.types.json && node scripts/mark-types-cjs.mjs",
     "clean": "rm -rf dist",
     "typescript": "tsc --noEmit",
     "test": "jest",
-    "lint": "biome lint --error-on-warnings ./src",
-    "prepublishOnly": "node ../../scripts/assert-bun-publish.mjs && bun run typescript && bun run test && bun run build"
+    "lint": "biome lint --error-on-warnings ./src"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",
-    "jest": "^30.5.1",
-    "jest-environment-jsdom": "^30.5.1",
-    "socket.io": "^4.8.1",
-    "socket.io-client": "^4.8.1",
-    "ts-jest": "^29.4.12",
-    "typescript": "^5.9.2"
+    "jest": "^30.5.2",
+    "jest-environment-jsdom": "^30.5.2",
+    "socket.io": "^4.8.4",
+    "socket.io-client": "^4.8.4",
+    "ts-jest": "^29.4.15",
+    "typescript": "~6.0.3"
   }
 }

package/src/__tests__/collector.test.ts

@@ -3,6 +3,7 @@ import { EventEmitter } from 'node:events';
 import {
   createTrafficCollector,
   instrumentTrafficFetch,
+  resolveOxyServiceEndpoint,
   trafficMiddleware,
   trafficType,
   type TrafficAggregate,
@@ -197,4 +198,20 @@ describe('ecosystem activity collector', () => {
     expect(trafficType('/api/v1/uploads/private-id?token=secret')).toBe('media');
     expect(trafficType('/v1/chat/completions')).toBe('ai');
   });
+
+  it('attributes the Gemies API to gemies and keeps Alia’s API as alia', () => {
+    expect(resolveOxyServiceEndpoint(new URL('https://api.gemies.ai/v1/chat'))).toEqual({
+      service: 'gemies',
+      region: 'us-west-2',
+    });
+    expect(resolveOxyServiceEndpoint(new URL('https://api.alia.onl/v1/chat'))?.service).toBe(
+      'alia',
+    );
+    // Exact host only: neither the web app nor a lookalike claims the service.
+    expect(resolveOxyServiceEndpoint(new URL('https://gemies.ai/'))).toBeUndefined();
+    expect(
+      resolveOxyServiceEndpoint(new URL('https://api.gemies.ai.evil.example/')),
+    ).toBeUndefined();
+    expect(resolveOxyServiceEndpoint(new URL('http://api.gemies.ai/'))).toBeUndefined();
+  });
 });

package/src/__tests__/emfGolden.test.ts

@@ -0,0 +1,53 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { createEmfPublisher, type MetricDefinition } from '../metrics';
+
+// The cross-language contract: Kaana's Go `internal/emf` runs the same file.
+// Numbers JSON cannot carry travel as the strings below.
+const SENTINELS: Record<string, number> = {
+  NaN: Number.NaN,
+  Infinity: Number.POSITIVE_INFINITY,
+  '-Infinity': Number.NEGATIVE_INFINITY,
+};
+
+interface GoldenCase {
+  name: string;
+  definition: MetricDefinition;
+  service: string;
+  namespace: string;
+  now: number;
+  maxSeries?: number;
+  observations: { labels: Record<string, string>; value: number | string }[];
+  expectedLines: unknown[];
+}
+
+const cases: GoldenCase[] = JSON.parse(
+  readFileSync(join(__dirname, '..', '..', 'fixtures', 'emf-golden.json'), 'utf8'),
+);
+
+describe('EMF golden fixture', () => {
+  it('is not empty and has unique case names', () => {
+    expect(cases.length).toBeGreaterThan(0);
+    expect(new Set(cases.map((entry) => entry.name)).size).toBe(cases.length);
+  });
+
+  it.each(cases.map((entry) => [entry.name, entry] as const))('%s', (_name, entry) => {
+    const lines: string[] = [];
+    const publisher = createEmfPublisher({
+      namespace: entry.namespace,
+      service: entry.service,
+      write: (line) => lines.push(line),
+      now: () => entry.now,
+      ...(entry.maxSeries === undefined ? {} : { maxSeries: entry.maxSeries }),
+    });
+    for (const { labels, value } of entry.observations) {
+      publisher.record(
+        entry.definition,
+        typeof value === 'string' ? SENTINELS[value] : value,
+        labels,
+      );
+    }
+    publisher.stop();
+    expect(lines.map((line) => JSON.parse(line))).toEqual(entry.expectedLines);
+  });
+});

package/src/__tests__/metrics.test.ts

@@ -0,0 +1,45 @@
+import { createEmfPublisher, HTTP_REQUEST_LATENCY, HTTP_RATE_LIMITED } from '../metrics';
+
+describe('EMF publisher', () => {
+  it('folds an interval into one EMF line per series with bounded dimensions', () => {
+    const lines: string[] = [];
+    const publisher = createEmfPublisher({
+      namespace: 'Oxy/Test',
+      service: 'svc',
+      write: (line) => lines.push(line),
+      now: () => 1_000,
+      maxSeries: 2,
+    });
+    const labels = { Route: '/users/:id', StatusClass: '2xx', Caller: 'anonymous' };
+    for (const ms of [10, 10, 200]) publisher.record(HTTP_REQUEST_LATENCY, ms, labels);
+    publisher.record(HTTP_RATE_LIMITED, 1, { Caller: 'service:app' });
+    // A third series exceeds maxSeries and folds into `other`.
+    publisher.record(HTTP_RATE_LIMITED, 1, { Caller: 'service:another' });
+    publisher.stop();
+
+    const [latency, limited, overflow] = lines.map((line) => JSON.parse(line));
+    expect(latency._aws).toEqual({
+      Timestamp: 1_000,
+      CloudWatchMetrics: [
+        {
+          Namespace: 'Oxy/Test',
+          Dimensions: [['Service'], ['Service', 'StatusClass'], ['Service', 'Caller']],
+          Metrics: [{ Name: 'RequestLatency', Unit: 'Milliseconds' }],
+        },
+      ],
+    });
+    expect(latency).toMatchObject({ Service: 'svc', Route: '/users/:id', StatusClass: '2xx' });
+    // Values are ~5 % buckets; Count/Sum/Min/Max stay exact.
+    expect(latency.RequestLatency.Values).toEqual([9.91, 204]);
+    expect(latency.RequestLatency).toMatchObject({
+      Counts: [2, 1],
+      Max: 200,
+      Min: 10,
+      Count: 3,
+      Sum: 220,
+    });
+    expect(limited).toMatchObject({ Caller: 'service:app', RateLimited: 1 });
+    expect(overflow).toMatchObject({ Caller: 'other', RateLimited: 1 });
+    expect(lines).toHaveLength(3);
+  });
+});

package/src/__tests__/singleSources.test.ts

@@ -0,0 +1,184 @@
+/** @jest-environment node */
+import { isObservedPath } from '../collector';
+import {
+  OXY_ACTIVITY_ID_HEADER,
+  OXY_EDGE_REGION_HEADER,
+  OXY_REGION_HEADER,
+  OXY_SOURCE_REGION_HEADER,
+  OXY_TELEMETRY_EXPOSED_HEADERS,
+  OXY_TELEMETRY_REQUEST_HEADERS,
+} from '../index';
+import { createEmfPublisherIfDeployed } from '../metrics';
+import { metadataFromHeaders, sourceRegionFromEdgePop } from '../server';
+
+describe('telemetry header lists', () => {
+  it('request headers are exactly the headers a browser sends', () => {
+    expect([...OXY_TELEMETRY_REQUEST_HEADERS]).toEqual([
+      OXY_ACTIVITY_ID_HEADER,
+      OXY_EDGE_REGION_HEADER,
+    ]);
+    expect(OXY_TELEMETRY_REQUEST_HEADERS).not.toContain(OXY_SOURCE_REGION_HEADER);
+  });
+
+  it('exposed headers are exactly the response headers a browser reads', () => {
+    expect([...OXY_TELEMETRY_EXPOSED_HEADERS]).toEqual([OXY_REGION_HEADER]);
+  });
+
+  it('the server reads the same headers the constants name', () => {
+    expect(
+      metadataFromHeaders({
+        [OXY_EDGE_REGION_HEADER.toLowerCase()]: 'MAD',
+        [OXY_ACTIVITY_ID_HEADER.toLowerCase()]: 'anonymous-runtime-a1',
+      }),
+    ).toEqual({ edgePop: 'mad', activityId: 'anonymous-runtime-a1' });
+  });
+});
+
+// The pre-change behaviour, copied verbatim from origin/main collector.ts
+// (middleware lines 119-124, instrumentTrafficFetch lines 200-202).
+const legacyInboundExcluded = (path: string): boolean =>
+  /^\/(?:api\/)?(?:health|ready|live|platform-stats|platform-activity|platform-infrastructure|infra-status)(?:\/|$)/.test(
+    path,
+  ) ||
+  path.startsWith('/internal/activity') ||
+  path.startsWith('/auth/service-token') ||
+  path.startsWith('/cdn-cgi/');
+const legacyOutboundExcluded = (pathname: string): boolean =>
+  pathname.startsWith('/internal/activity') ||
+  pathname.startsWith('/auth/service-token') ||
+  pathname === '/platform-infrastructure';
+
+const PATHS = [
+  '/',
+  '/users/me',
+  '/api/v1/users',
+  '/auth/session',
+  '/healthy',
+  '/readyz',
+  '/cdn-cgi',
+  '/health',
+  '/health/deep',
+  '/health?x=1',
+  '/api/health',
+  '/api/health/x',
+  '/ready',
+  '/api/ready',
+  '/live',
+  '/api/live',
+  '/platform-stats',
+  '/platform-stats/stream',
+  '/api/platform-stats',
+  '/platform-activity',
+  '/platform-activity/x',
+  '/api/platform-activity',
+  '/infra-status',
+  '/infra-status/x',
+  '/api/infra-status',
+  '/platform-infrastructure',
+  '/platform-infrastructure/',
+  '/platform-infrastructure/x',
+  '/api/platform-infrastructure',
+  '/api/platform-infrastructure/x',
+  '/platform-infrastructures',
+  '/api/api/health',
+  '/internal/activity',
+  '/internal/activity/batch',
+  '/internal/activityx',
+  '/auth/service-token',
+  '/auth/service-token/x',
+  '/auth/service-tokens',
+  '/cdn-cgi/',
+  '/cdn-cgi/trace',
+  '/v1/health',
+];
+
+describe('isObservedPath', () => {
+  it.each(PATHS)('%s matches the pre-change inbound behaviour', (path) => {
+    expect(isObservedPath(path, 'inbound')).toBe(!legacyInboundExcluded(path));
+  });
+
+  it.each(PATHS)('%s matches the pre-change outbound behaviour', (path) => {
+    expect(isObservedPath(path, 'outbound')).toBe(!legacyOutboundExcluded(path));
+  });
+
+  it('pins the excluded sets explicitly in both directions', () => {
+    const excluded = (direction: 'inbound' | 'outbound') =>
+      PATHS.filter((path) => !isObservedPath(path, direction));
+    expect(excluded('outbound')).toEqual([
+      '/platform-infrastructure',
+      '/internal/activity',
+      '/internal/activity/batch',
+      '/internal/activityx',
+      '/auth/service-token',
+      '/auth/service-token/x',
+      '/auth/service-tokens',
+    ]);
+    expect(excluded('inbound')).toEqual(PATHS.filter(legacyInboundExcluded));
+    // Excluded inbound only today; recorded outbound. Unifying is an owner decision.
+    expect(excluded('inbound').filter((path) => isObservedPath(path, 'outbound'))).toContain(
+      '/platform-stats',
+    );
+  });
+});
+
+describe('sourceRegionFromEdgePop', () => {
+  it('prefixes a PoP and passes absence through', () => {
+    expect(sourceRegionFromEdgePop('mad')).toBe('edge-mad');
+    expect(sourceRegionFromEdgePop(undefined)).toBeUndefined();
+    expect(sourceRegionFromEdgePop('')).toBeUndefined();
+  });
+});
+
+describe('createEmfPublisherIfDeployed', () => {
+  const options = { namespace: 'Oxy/Test', service: 'svc', write: () => {} };
+
+  it('returns null off ECS', () => {
+    expect(createEmfPublisherIfDeployed(options, {})).toBeNull();
+    expect(createEmfPublisherIfDeployed(options, { ECS_CONTAINER_METADATA_URI_V4: '' })).toBeNull();
+  });
+
+  it('returns a publisher on ECS', () => {
+    const publisher = createEmfPublisherIfDeployed(options, {
+      ECS_CONTAINER_METADATA_URI_V4: 'http://169.254.170.2/v4/task',
+    });
+    expect(publisher).not.toBeNull();
+    publisher?.stop();
+  });
+
+  it('reads process.env by default', () => {
+    const previous = process.env.ECS_CONTAINER_METADATA_URI_V4;
+    delete process.env.ECS_CONTAINER_METADATA_URI_V4;
+    try {
+      expect(createEmfPublisherIfDeployed(options)).toBeNull();
+    } finally {
+      if (previous !== undefined) process.env.ECS_CONTAINER_METADATA_URI_V4 = previous;
+    }
+  });
+});
+
+describe('instrumentTrafficFetch exclusion', () => {
+  it('skips control requests and still records outbound calls to inbound-excluded paths', async () => {
+    const { createTrafficCollector, instrumentTrafficFetch } = await import('../collector');
+    const published: unknown[][] = [];
+    const collector = createTrafficCollector(async (events) => {
+      published.push(events);
+    });
+    const fetcher = jest.fn(async () => new Response('ok')) as unknown as typeof fetch;
+    const observed = instrumentTrafficFetch(
+      fetcher,
+      collector,
+      'svc',
+      'us-west-2',
+      () => undefined,
+    );
+    await observed('https://example.com/internal/activity');
+    await observed('https://example.com/auth/service-token');
+    await observed('https://example.com/platform-infrastructure');
+    await collector.flush();
+    expect(published).toHaveLength(0);
+    // Recorded outbound today, though excluded inbound.
+    await observed('https://example.com/platform-stats');
+    await collector.flush();
+    expect(published).toHaveLength(1);
+  });
+});

package/src/browser.ts

@@ -60,6 +60,12 @@ function eligibleLocation(location: Pick<Location, 'hostname' | 'protocol'> | un
   );
 }
 
+/**
+ * @deprecated No Oxy repo constructs its own runtime: use the module-level
+ * `getBrowserActivityIdHeader`, `getBrowserEdgeRegionHeader` and
+ * `peekBrowserEdgeRegionHeader`. The factory remains the test seam. Removal from
+ * the public surface is planned for the next major.
+ */
 export function createBrowserTelemetry(options: BrowserTelemetryOptions = {}): BrowserTelemetry {
   let activityId: string | null = null;
   let activityIdCreatedAt = 0;
@@ -169,5 +175,10 @@ export const getBrowserEdgeRegionHeader = (): Promise<Record<string, string>> =>
 export const peekBrowserEdgeRegionHeader = (): Record<string, string> =>
   defaultBrowserTelemetry.peekEdgeRegionHeader();
 
+/**
+ * @deprecated Unused by any Oxy repo. `@oxy.so/core` sends
+ * `peekBrowserEdgeRegionHeader()` and `getBrowserActivityIdHeader()` per request.
+ * Removal is planned for the next major.
+ */
 export const getBrowserTelemetryHeaders = (): Promise<Record<string, string>> =>
   defaultBrowserTelemetry.getHeaders();