autotel 3.5.0 → 3.7.0

package/src/validate.test.ts

@@ -0,0 +1,287 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { trace } from '@opentelemetry/api';
+
+const counterAdd = vi.hoisted(() => vi.fn());
+vi.mock('./metric-helpers', () => ({
+  createCounter: () => ({ add: counterAdd }),
+}));
+
+import {
+  defineValidator,
+  recordValidationMismatch,
+  formatValidationIssues,
+  onValidationMismatch,
+  type ValidationMismatch,
+} from './validate';
+import { VALIDATION_ATTR } from './validation-attributes';
+
+/** A fake `SchemaLike` so tests don't depend on Zod. */
+function schema<T>(
+  decide: (
+    input: unknown,
+  ) => { success: true; data: T } | { success: false; error: unknown },
+) {
+  return { safeParse: decide };
+}
+
+/** A Zod-shaped error whose message/received embed a secret value. */
+const SECRET = '123-45-6789';
+const zodLikeError = {
+  issues: [
+    {
+      path: ['user', 'ssn'],
+      code: 'invalid_type',
+      expected: 'string',
+      received: SECRET, // value — must never escape
+      message: `Expected string, received ${SECRET}`, // value — must never escape
+    },
+  ],
+};
+
+let setAttributes: ReturnType<typeof vi.fn>;
+
+beforeEach(() => {
+  setAttributes = vi.fn();
+  vi.spyOn(trace, 'getActiveSpan').mockReturnValue({
+    setAttributes,
+  } as never);
+  counterAdd.mockClear();
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe('formatValidationIssues — PII guard', () => {
+  it('keeps only path, code, and declared type — never values or messages', () => {
+    const issues = formatValidationIssues(zodLikeError);
+    expect(issues).toEqual([
+      { path: 'user.ssn', code: 'invalid_type', expected: 'string' },
+    ]);
+    // The secret must not appear anywhere in the serialized output.
+    expect(JSON.stringify(issues)).not.toContain(SECRET);
+  });
+
+  it('handles a generic { errors: [...] } shape', () => {
+    const issues = formatValidationIssues({
+      errors: [{ path: ['a'], code: 'custom' }],
+    });
+    expect(issues).toEqual([{ path: 'a', code: 'custom' }]);
+  });
+
+  it('returns [] for unrecognised errors', () => {
+    expect(formatValidationIssues(new Error('boom'))).toEqual([]);
+    expect(formatValidationIssues()).toEqual([]);
+    expect(formatValidationIssues('nope')).toEqual([]);
+  });
+
+  it('defaults a missing code and root path', () => {
+    expect(formatValidationIssues({ issues: [{}] })).toEqual([
+      { path: '', code: 'invalid' },
+    ]);
+  });
+});
+
+describe('recordValidationMismatch', () => {
+  const mismatch: ValidationMismatch = {
+    name: 'POST /orders',
+    boundary: 'http',
+    mode: 'reject',
+    issues: [
+      { path: 'a', code: 'invalid_type' },
+      { path: 'b', code: 'too_small' },
+      { path: 'c', code: 'invalid_type' },
+    ],
+    hash: 'abc123',
+    severity: 'warning',
+  };
+
+  it('sets validation.* attributes on the active span', () => {
+    recordValidationMismatch(mismatch);
+    expect(setAttributes).toHaveBeenCalledWith(
+      expect.objectContaining({
+        [VALIDATION_ATTR.name]: 'POST /orders',
+        [VALIDATION_ATTR.boundary]: 'http',
+        [VALIDATION_ATTR.mode]: 'reject',
+        [VALIDATION_ATTR.issueCount]: 3,
+        [VALIDATION_ATTR.issuePaths]: 'a,b,c',
+        [VALIDATION_ATTR.issueCodes]: 'invalid_type,too_small', // deduped
+        [VALIDATION_ATTR.hash]: 'abc123',
+        [VALIDATION_ATTR.severity]: 'warning',
+      }),
+    );
+  });
+
+  it('increments the mismatch counter with boundary/validation/mode labels', () => {
+    recordValidationMismatch(mismatch);
+    expect(counterAdd).toHaveBeenCalledWith(1, {
+      boundary: 'http',
+      validation: 'POST /orders',
+      mode: 'reject',
+    });
+  });
+
+  it('skips span attributes when there is no active span (fail-open)', () => {
+    vi.spyOn(trace, 'getActiveSpan').mockReturnValue();
+    expect(() => recordValidationMismatch(mismatch)).not.toThrow();
+  });
+
+  it('never throws even if the span sink throws', () => {
+    setAttributes.mockImplementation(() => {
+      throw new Error('span boom');
+    });
+    expect(() => recordValidationMismatch(mismatch)).not.toThrow();
+  });
+});
+
+describe('onValidationMismatch', () => {
+  const mismatch = (name: string): ValidationMismatch => ({
+    name,
+    boundary: 'event',
+    mode: 'observe',
+    issues: [],
+  });
+
+  // The listener registry is module-global; track every unsubscribe so a test
+  // can't leak a subscriber into the next one.
+  const cleanups: Array<() => void> = [];
+  const register = (handler: (m: ValidationMismatch) => void) => {
+    const off = onValidationMismatch(handler);
+    cleanups.push(off);
+    return off;
+  };
+  afterEach(() => {
+    while (cleanups.length > 0) cleanups.pop()!();
+  });
+
+  it('invokes a registered listener and can unsubscribe', () => {
+    const seen: ValidationMismatch[] = [];
+    const off = register((m) => seen.push(m));
+    recordValidationMismatch(mismatch('x'));
+    expect(seen).toHaveLength(1);
+    off();
+    recordValidationMismatch(mismatch('y'));
+    expect(seen).toHaveLength(1); // not called after unsubscribe
+  });
+
+  it('delivers each mismatch to every simultaneous subscriber', () => {
+    // The real case: autotel-audit registers a security bridge while the app
+    // registers its own webhook/logger — both must fire.
+    const audit: string[] = [];
+    const webhook: string[] = [];
+    register((m) => audit.push(m.name));
+    register((m) => webhook.push(m.name));
+
+    recordValidationMismatch(mismatch('POST /login'));
+
+    expect(audit).toEqual(['POST /login']);
+    expect(webhook).toEqual(['POST /login']);
+  });
+
+  it('unsubscribes each subscriber independently', () => {
+    const a: string[] = [];
+    const b: string[] = [];
+    const offA = register((m) => a.push(m.name));
+    register((m) => b.push(m.name));
+
+    recordValidationMismatch(mismatch('first'));
+    offA(); // remove only A
+    recordValidationMismatch(mismatch('second'));
+
+    expect(a).toEqual(['first']); // A stopped after unsubscribe
+    expect(b).toEqual(['first', 'second']); // B keeps firing
+  });
+
+  it('isolates faults: a throwing subscriber neither throws nor starves peers', () => {
+    const survivor: string[] = [];
+    register(() => {
+      throw new Error('subscriber boom');
+    });
+    register((m) => survivor.push(m.name));
+
+    expect(() => recordValidationMismatch(mismatch('z'))).not.toThrow();
+    expect(survivor).toEqual(['z']); // the healthy subscriber still fired
+  });
+
+  it('treats a re-registered identical handler as a single subscription', () => {
+    const seen: string[] = [];
+    const handler = (m: ValidationMismatch) => seen.push(m.name);
+    register(handler);
+    register(handler); // Set semantics → still one
+    recordValidationMismatch(mismatch('once'));
+    expect(seen).toEqual(['once']);
+  });
+});
+
+describe('defineValidator', () => {
+  const ok = schema<{ a: number }>(() => ({ success: true, data: { a: 1 } }));
+  const bad = schema<{ a: number }>(() => ({
+    success: false,
+    error: zodLikeError,
+  }));
+
+  it('reject mode (default): records then throws a 400 structured error', () => {
+    const v = defineValidator('POST /orders', bad, { boundary: 'http' });
+    expect(v.mode).toBe('reject');
+    try {
+      v.parse({ user: { ssn: SECRET } });
+      throw new Error('should have thrown');
+    } catch (error) {
+      const e = error as { status?: number; code?: string; message: string };
+      expect(e.status).toBe(400);
+      expect(e.code).toBe('validation_failed');
+      // even the thrown error must not leak the value
+      expect(JSON.stringify({ m: e.message })).not.toContain(SECRET);
+    }
+    expect(setAttributes).toHaveBeenCalled();
+  });
+
+  it('observe mode: records then returns the raw input (no throw)', () => {
+    const v = defineValidator('order.placed', bad, {
+      boundary: 'event',
+      onMismatch: 'observe',
+    });
+    const raw = { user: { ssn: SECRET } };
+    expect(v.parse(raw)).toBe(raw);
+    expect(setAttributes).toHaveBeenCalledWith(
+      expect.objectContaining({ [VALIDATION_ATTR.mode]: 'observe' }),
+    );
+  });
+
+  it('returns parsed data and records nothing on success', () => {
+    const v = defineValidator('ok', ok);
+    expect(v.parse({})).toEqual({ a: 1 });
+    expect(setAttributes).not.toHaveBeenCalled();
+    expect(counterAdd).not.toHaveBeenCalled();
+  });
+
+  it('safeParse returns a discriminated result and never throws', () => {
+    const v = defineValidator('POST /orders', bad);
+    const result = v.safeParse({});
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.issues[0]).toEqual({
+        path: 'user.ssn',
+        code: 'invalid_type',
+        expected: 'string',
+      });
+    }
+  });
+
+  it('honors a custom onReject error builder', () => {
+    const v = defineValidator('x', bad, {
+      onReject: () => new Error('custom reject'),
+    });
+    expect(() => v.parse({})).toThrow('custom reject');
+  });
+
+  it('emits a stable validation.hash when toJsonSchema is provided', () => {
+    const v = defineValidator('x', bad, {
+      toJsonSchema: () => ({ type: 'object' }),
+    });
+    v.safeParse({});
+    const attrs = setAttributes.mock.calls[0][0];
+    expect(typeof attrs[VALIDATION_ATTR.hash]).toBe('string');
+    expect(attrs[VALIDATION_ATTR.hash]).toHaveLength(64); // sha256 hex
+  });
+});

package/src/validate.ts

@@ -0,0 +1,307 @@
+/**
+ * Validation telemetry — connect runtime input validation (Zod or any
+ * `safeParse` schema) to your traces and metrics at the boundaries where bad
+ * data actually enters: HTTP bodies, events, messages.
+ *
+ * Today a `safeParse` failure either throws (no span, no metric, no alert) or
+ * is silently swallowed in a handler. `defineValidator` makes the mismatch
+ * **observable** — a `validation.*` span attribute set and a counter
+ * incremented — with a per-validator `observe` vs `reject` mode:
+ *
+ * - `reject` (default): record telemetry, then throw a structured 400-shaped
+ *   error so the boundary can fail cleanly.
+ * - `observe`: record telemetry, return the raw input so the handler continues
+ *   — useful for measuring real-world drift before you enforce it.
+ *
+ * **Not a security feature by default.** A malformed body is usually a bug or
+ * version skew, not an attack. Validation telemetry is first-class on its own
+ * metric; escalation to the security path is a deliberate opt-in via
+ * {@link onValidationMismatch} (e.g. wired by `autotel-audit`), never automatic.
+ *
+ * **PII-safe by construction.** Only field *paths*, issue *codes*, and the
+ * declared *type* are ever recorded — never the offending value, and never a
+ * validator's error `message` (which routinely embeds the received value).
+ */
+
+import { trace } from '@opentelemetry/api';
+import { createCounter } from './metric-helpers';
+import {
+  createStructuredError,
+  type StructuredError,
+} from './structured-error';
+import { hashJson } from './stable-hash';
+import type { SchemaLike } from './define-event';
+import {
+  VALIDATION_ATTR,
+  VALIDATION_ISSUE_CAP,
+  VALIDATION_METRICS,
+} from './validation-attributes';
+
+export type { SchemaLike } from './define-event';
+
+export type ValidationMode = 'observe' | 'reject';
+export type ValidationSeverity = 'info' | 'warning' | 'error';
+
+/** A single failing field, stripped of any payload values. */
+export interface ValidationIssue {
+  /** Dotted field path, e.g. `items.0.price`. Never a value. */
+  path: string;
+  /** Issue code (e.g. Zod's `invalid_type`, `too_small`). Never a value. */
+  code: string;
+  /** Declared type/constraint summary, e.g. `string`. Never a received value. */
+  expected?: string;
+}
+
+/** Everything the recorder needs — already PII-stripped by the caller. */
+export interface ValidationMismatch {
+  /** Contract id, e.g. `POST /orders` or `order.placed`. */
+  name: string;
+  boundary: string;
+  mode: ValidationMode;
+  issues: ValidationIssue[];
+  hash?: string;
+  severity?: ValidationSeverity;
+}
+
+let mismatchCounter: ReturnType<typeof createCounter> | undefined;
+function counter(): ReturnType<typeof createCounter> {
+  if (!mismatchCounter) {
+    mismatchCounter = createCounter(VALIDATION_METRICS.mismatches, {
+      description: 'Input payloads that did not match their declared shape',
+    });
+  }
+  return mismatchCounter;
+}
+
+type MismatchListener = (mismatch: ValidationMismatch) => void;
+const listeners = new Set<MismatchListener>();
+
+/**
+ * Register an explicit handler called on every recorded mismatch — the opt-in
+ * seam for escalating to security events, a webhook, or a custom sink. There is
+ * no automatic, package-presence-driven escalation: nothing fires here unless
+ * you (or a package you wire up) register a handler.
+ *
+ * Multiple subscribers coexist: a package (e.g. `autotel-audit` bridging to
+ * security events) and your own app code (a webhook, a logger) can both
+ * register and all fire. Returns an unsubscribe fn that removes only this
+ * handler; registering the same function twice is a no-op (Set semantics).
+ */
+export function onValidationMismatch(handler: MismatchListener): () => void {
+  listeners.add(handler);
+  return () => {
+    listeners.delete(handler);
+  };
+}
+
+const truncate = (values: string[]): string =>
+  values.slice(0, VALIDATION_ISSUE_CAP).join(',');
+
+/**
+ * Record a validation mismatch as telemetry: `validation.*` attributes on the
+ * active span (if any) and an increment on `autotel.validation.mismatches`.
+ * Fail-open — never throws, so instrumentation can't break the boundary.
+ */
+export function recordValidationMismatch(mismatch: ValidationMismatch): void {
+  try {
+    const paths = mismatch.issues.map((i) => i.path).filter(Boolean);
+    const codes = [...new Set(mismatch.issues.map((i) => i.code))];
+
+    const span = trace.getActiveSpan();
+    if (span) {
+      span.setAttributes({
+        [VALIDATION_ATTR.name]: mismatch.name,
+        [VALIDATION_ATTR.boundary]: mismatch.boundary,
+        [VALIDATION_ATTR.mode]: mismatch.mode,
+        [VALIDATION_ATTR.issueCount]: mismatch.issues.length,
+        [VALIDATION_ATTR.issuePaths]: truncate(paths),
+        [VALIDATION_ATTR.issueCodes]: truncate(codes),
+        ...(mismatch.hash ? { [VALIDATION_ATTR.hash]: mismatch.hash } : {}),
+        ...(mismatch.severity
+          ? { [VALIDATION_ATTR.severity]: mismatch.severity }
+          : {}),
+      });
+    }
+
+    try {
+      counter().add(1, {
+        boundary: mismatch.boundary,
+        validation: mismatch.name,
+        mode: mismatch.mode,
+      });
+    } catch {
+      // meter not initialised yet — skip the count, keep the span attrs
+    }
+
+    // Dispatch to every subscriber with per-listener fault isolation: one
+    // throwing subscriber must not starve its peers or break the boundary.
+    // Set iteration tolerates concurrent (un)subscription safely.
+    for (const listener of listeners) {
+      try {
+        listener(mismatch);
+      } catch {
+        // a misbehaving subscriber must not break the boundary or its peers
+      }
+    }
+  } catch {
+    // fail-open: telemetry must never break the validated boundary
+  }
+}
+
+/**
+ * Normalise an arbitrary validation error into PII-safe issues. Reads only
+ * `path`, `code`, and (when it is a declared type name) `expected` — and never
+ * `message`, `received`, or any value-bearing field. Understands the Zod shape
+ * (`error.issues`) and a generic `error.errors` fallback; returns `[]` for
+ * anything unrecognised.
+ */
+export function formatValidationIssues(error: unknown): ValidationIssue[] {
+  const raw = extractRawIssues(error);
+  return raw.map((issue) => toSafeIssue(issue));
+}
+
+function extractRawIssues(error: unknown): Array<Record<string, unknown>> {
+  if (error && typeof error === 'object') {
+    const candidate =
+      (error as { issues?: unknown }).issues ??
+      (error as { errors?: unknown }).errors;
+    if (Array.isArray(candidate)) {
+      return candidate.filter(
+        (i): i is Record<string, unknown> =>
+          i !== null && typeof i === 'object',
+      );
+    }
+  }
+  return [];
+}
+
+function toSafeIssue(issue: Record<string, unknown>): ValidationIssue {
+  const rawPath = issue.path;
+  const path = Array.isArray(rawPath)
+    ? rawPath.map(String).join('.')
+    : typeof rawPath === 'string'
+      ? rawPath
+      : '';
+  const code = typeof issue.code === 'string' ? issue.code : 'invalid';
+  // `expected` is a declared type name in Zod (e.g. 'string'); safe. We never
+  // read `received`/`message`/`value`, which can carry the offending payload.
+  const expected =
+    typeof issue.expected === 'string' ? issue.expected : undefined;
+  return expected ? { path, code, expected } : { path, code };
+}
+
+export interface DefineValidatorOptions<S> {
+  /** Where validation runs. Defaults to `input`. */
+  boundary?: string;
+  /** `reject` (default): record then throw. `observe`: record then continue. */
+  onMismatch?: ValidationMode;
+  /** Project the schema to JSON Schema for a stable `validation.hash`. */
+  toJsonSchema?: (schema: S) => unknown;
+  severity?: ValidationSeverity;
+  /** Build the error thrown in `reject` mode (defaults to a 400 structured error). */
+  onReject?: (issues: ValidationIssue[], name: string) => Error;
+}
+
+export type ValidatorResult<T> =
+  | { success: true; data: T }
+  | { success: false; issues: ValidationIssue[] };
+
+export interface Validator<T> {
+  readonly name: string;
+  readonly mode: ValidationMode;
+  /** Validate and record on failure; never throws. */
+  safeParse(input: unknown): ValidatorResult<T>;
+  /**
+   * Validate, record on failure, then apply the mode: `reject` throws,
+   * `observe` returns the raw input so the handler can continue.
+   */
+  parse(input: unknown): T;
+}
+
+function defaultRejectError(
+  issues: ValidationIssue[],
+  name: string,
+): StructuredError {
+  return createStructuredError({
+    name: 'ValidationError',
+    status: 400,
+    code: 'validation_failed',
+    message: `Input for "${name}" did not match its declared shape.`,
+    why: `${issues.length} field(s) failed validation: ${issues
+      .map((i) => i.path || '(root)')
+      .slice(0, VALIDATION_ISSUE_CAP)
+      .join(', ')}.`,
+    fix: 'Send a payload that matches the schema, or switch this validator to observe mode while you investigate.',
+    // PII-safe: paths + codes only, no received values.
+    details: { validation: name, issues },
+  });
+}
+
+/**
+ * Declare an expected input shape once and get a validator that records every
+ * mismatch as telemetry.
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zod';
+ * import { defineValidator } from 'autotel/validate';
+ *
+ * const OrderBody = defineValidator('POST /orders', z.object({
+ *   items: z.array(z.object({ sku: z.string(), qty: z.number().int() })),
+ * }), { boundary: 'http', toJsonSchema: (s) => z.toJSONSchema(s) });
+ *
+ * // reject mode (default): records + throws a 400-shaped structured error
+ * const order = OrderBody.parse(req.body);
+ *
+ * // observe mode: records, returns the result, never throws
+ * const result = OrderBody.safeParse(req.body);
+ * if (!result.success) metrics.onDrift(result.issues);
+ * ```
+ */
+export function defineValidator<T, S extends SchemaLike<T>>(
+  name: string,
+  schema: S,
+  options: DefineValidatorOptions<S> = {},
+): Validator<T> {
+  const mode = options.onMismatch ?? 'reject';
+  const boundary = options.boundary ?? 'input';
+  const hash = options.toJsonSchema
+    ? hashJson(options.toJsonSchema(schema))
+    : undefined;
+
+  const record = (issues: ValidationIssue[]): void => {
+    recordValidationMismatch({
+      name,
+      boundary,
+      mode,
+      issues,
+      hash,
+      severity: options.severity,
+    });
+  };
+
+  return {
+    name,
+    mode,
+    safeParse(input: unknown): ValidatorResult<T> {
+      const parsed = schema.safeParse(input);
+      if (parsed.success) return { success: true, data: parsed.data };
+      const issues = formatValidationIssues(parsed.error);
+      record(issues);
+      return { success: false, issues };
+    },
+    parse(input: unknown): T {
+      const parsed = schema.safeParse(input);
+      if (parsed.success) return parsed.data;
+      const issues = formatValidationIssues(parsed.error);
+      record(issues);
+      if (mode === 'reject') {
+        throw (
+          options.onReject?.(issues, name) ?? defaultRejectError(issues, name)
+        );
+      }
+      // observe: continue with the raw input (documented type caveat)
+      return input as T;
+    },
+  };
+}

package/src/validation-attributes.ts

@@ -0,0 +1,43 @@
+/**
+ * Validation telemetry wire constants — the single source of truth for the
+ * `validation.*` span attributes and the `autotel.validation.mismatches` metric
+ * emitted when an input payload (HTTP body, event, message) fails to match its
+ * declared shape.
+ *
+ * Dependency-free and side-effect-free by design (mirrors `security-schema.ts`):
+ * safe to import from anything that only needs the constant strings — a
+ * dashboard, a CLI, an alert rule — without pulling in the OpenTelemetry SDK.
+ *
+ * These keys are a public API for the agents that query your telemetry. Treat a
+ * rename here the way you'd treat a breaking change to any other contract.
+ */
+
+export const VALIDATION_ATTR = {
+  /** Contract id of the validated boundary, e.g. `POST /orders`, `order.placed`. */
+  name: 'validation.name',
+  /** Where validation ran: `http` | `event` | `message` | a custom label. */
+  boundary: 'validation.boundary',
+  /** `observe` (recorded, request continues) or `reject` (recorded, then failed). */
+  mode: 'validation.mode',
+  /** Stable hash of the declared shape, when a JSON-schema projection is given. */
+  hash: 'validation.hash',
+  /** `info` | `warning` | `error`. */
+  severity: 'validation.severity',
+  /** Number of failing fields. */
+  issueCount: 'validation.issue.count',
+  /** Comma-separated failing field paths (capped). Never contains values. */
+  issuePaths: 'validation.issue.paths',
+  /** Comma-separated distinct issue codes (capped). Never contains values. */
+  issueCodes: 'validation.issue.codes',
+} as const;
+
+export type ValidationAttributeKey =
+  (typeof VALIDATION_ATTR)[keyof typeof VALIDATION_ATTR];
+
+export const VALIDATION_METRICS = {
+  /** Counter, labelled `{ boundary, validation, mode }`. */
+  mismatches: 'autotel.validation.mismatches',
+} as const;
+
+/** Max field paths / codes stamped onto a span, to bound attribute size. */
+export const VALIDATION_ISSUE_CAP = 20;

package/dist/attributes.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"attributes.cjs"}

package/dist/attributes.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"attributes.js"}

package/dist/chunk-2ZKEORFN.cjs

@@ -1,14 +0,0 @@
-'use strict';
-
-// src/semantic-conventions.ts
-function httpRequestHeaderAttribute(name) {
-  return `http.request.header.${name.toLowerCase()}`;
-}
-function httpResponseHeaderAttribute(name) {
-  return `http.response.header.${name.toLowerCase()}`;
-}
-
-exports.httpRequestHeaderAttribute = httpRequestHeaderAttribute;
-exports.httpResponseHeaderAttribute = httpResponseHeaderAttribute;
-//# sourceMappingURL=chunk-2ZKEORFN.cjs.map
-//# sourceMappingURL=chunk-2ZKEORFN.cjs.map

package/dist/chunk-2ZKEORFN.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/semantic-conventions.ts"],"names":[],"mappings":";;;AAQO,SAAS,2BAA2B,IAAA,EAAsB;AAC/D,EAAA,OAAO,CAAA,oBAAA,EAAuB,IAAA,CAAK,WAAA,EAAa,CAAA,CAAA;AAClD;AAEO,SAAS,4BAA4B,IAAA,EAAsB;AAChE,EAAA,OAAO,CAAA,qBAAA,EAAwB,IAAA,CAAK,WAAA,EAAa,CAAA,CAAA;AACnD","file":"chunk-2ZKEORFN.cjs","sourcesContent":["import {\n  HTTPAttributes,\n  ServiceAttributes,\n  URLAttributes,\n} from './attributes/registry';\n\nexport { HTTPAttributes, ServiceAttributes, URLAttributes };\n\nexport function httpRequestHeaderAttribute(name: string): string {\n  return `http.request.header.${name.toLowerCase()}`;\n}\n\nexport function httpResponseHeaderAttribute(name: string): string {\n  return `http.response.header.${name.toLowerCase()}`;\n}\n"]}