autotel 4.1.0 → 4.2.0

package/src/attributes/attachers.ts

@@ -1,161 +0,0 @@
-/**
- * Signal attachment helpers
- * These functions know WHERE to attach attributes automatically
- * They handle span, resource, and log signals correctly
- */
-
-import type { Span, Attributes } from '@opentelemetry/api';
-import {
-  resourceFromAttributes,
-  type Resource,
-} from '@opentelemetry/resources';
-import type { TraceContext } from '../trace-context';
-import { attrs } from './builders';
-import { safeSetAttributes } from './utils';
-
-export function setUser(
-  spanOrContext: Span | TraceContext,
-  data: import('./types').UserAttrs,
-  guardrails?: import('./validators').AttributePolicy,
-): void {
-  const attributes = attrs.user.data(data);
-  safeSetAttributes(spanOrContext, attributes, guardrails);
-}
-
-export function setSession(
-  spanOrContext: Span | TraceContext,
-  data: import('./types').SessionAttrs,
-  guardrails?: import('./validators').AttributePolicy,
-): void {
-  const attributes = attrs.session.data(data);
-  safeSetAttributes(spanOrContext, attributes, guardrails);
-}
-
-export function setDevice(
-  spanOrContext: Span | TraceContext,
-  data: import('./types').DeviceAttrs,
-  guardrails?: import('./validators').AttributePolicy,
-): void {
-  const attributes = attrs.device.data(data);
-  safeSetAttributes(spanOrContext, attributes, guardrails);
-}
-
-export function httpServer(
-  spanOrContext: Span | TraceContext,
-  data: import('./types').HTTPServerAttrs,
-  guardrails?: import('./validators').AttributePolicy,
-): void {
-  const attributes = attrs.http.server(data);
-
-  if ('updateName' in spanOrContext && data.method && data.route) {
-    const span = spanOrContext as Span;
-    span.updateName(`HTTP ${data.method} ${data.route}`);
-  }
-
-  safeSetAttributes(spanOrContext, attributes, guardrails);
-}
-
-export function httpClient(
-  spanOrContext: Span | TraceContext,
-  data: import('./types').HTTPClientAttrs,
-  guardrails?: import('./validators').AttributePolicy,
-): void {
-  const attributes = attrs.http.client(data);
-  safeSetAttributes(spanOrContext, attributes, guardrails);
-}
-
-export function dbClient(
-  spanOrContext: Span | TraceContext,
-  data: import('./types').DBAttrs,
-  guardrails?: import('./validators').AttributePolicy,
-): void {
-  const attributes = attrs.db.client.data(data);
-  safeSetAttributes(spanOrContext, attributes, guardrails);
-}
-
-/**
- * Merge service attributes into a Resource and return a new Resource.
- *
- * Resource.attributes is readonly, so this function returns a new merged
- * Resource rather than mutating the input.
- *
- * @param resource - The existing resource to merge with
- * @param data - Service attributes to add
- * @returns A new Resource with the merged attributes
- *
- * @example
- * ```typescript
- * const baseResource = Resource.default();
- * const enrichedResource = mergeServiceResource(baseResource, {
- *   name: 'my-service',
- *   version: '1.0.0',
- * });
- * ```
- */
-export function mergeServiceResource(
-  resource: Resource,
-  data: import('./types').ServiceAttrs,
-): Resource {
-  const attributes = attrs.service.data(data);
-  return resource.merge(resourceFromAttributes(attributes as Attributes));
-}
-
-export function identify(
-  spanOrContext: Span | TraceContext,
-  data: {
-    user?: import('./types').UserAttrs;
-    session?: import('./types').SessionAttrs;
-    device?: import('./types').DeviceAttrs;
-  },
-  guardrails?: import('./validators').AttributePolicy,
-): void {
-  const allAttrs = [];
-
-  if (data.user) {
-    allAttrs.push(attrs.user.data(data.user));
-  }
-  if (data.session) {
-    allAttrs.push(attrs.session.data(data.session));
-  }
-  if (data.device) {
-    allAttrs.push(attrs.device.data(data.device));
-  }
-
-  const merged: Record<string, unknown> = {};
-  for (const attrSet of allAttrs) {
-    Object.assign(merged, attrSet);
-  }
-
-  safeSetAttributes(spanOrContext, merged, guardrails);
-}
-
-export function request(
-  spanOrContext: Span | TraceContext,
-  data: import('./types').HTTPServerAttrs & {
-    clientIp?: string;
-  },
-  guardrails?: import('./validators').AttributePolicy,
-): void {
-  const httpAttrs = attrs.http.server(data);
-  const networkAttrs = attrs.network.peerAddress(data.clientIp || '');
-  const merged = { ...httpAttrs, ...networkAttrs };
-  safeSetAttributes(spanOrContext, merged, guardrails);
-}
-
-export function setError(
-  spanOrContext: Span | TraceContext,
-  data: import('./types').ErrorAttrs,
-  guardrails?: import('./validators').AttributePolicy,
-): void {
-  const attributes = attrs.error.data(data);
-  safeSetAttributes(spanOrContext, attributes, guardrails);
-}
-
-export function setException(
-  spanOrContext: Span | TraceContext,
-  data: import('./types').ExceptionAttrs,
-  guardrails?: import('./validators').AttributePolicy,
-): void {
-  const attributes = attrs.exception.data(data);
-  safeSetAttributes(spanOrContext, attributes, guardrails);
-}

package/src/attributes/builders.ts

@@ -1,529 +0,0 @@
-/**
- * Attribute builders for constructing OpenTelemetry attributes
- * Provides both key builders (Pattern A) and object builders (Pattern B)
- *
- * @example Pattern A: Key builders
- * ```typescript
- * attrs.user.id('123')                              // { 'user.id': '123' }
- * attrs.user.email('user@example.com')                 // { 'user.email': 'user@example.com' }
- * attrs.http.request.method('GET')                   // { 'http.request.method': 'GET' }
- * attrs.http.response.statusCode(200)                 // { 'http.response.status_code': 200 }
- * ```
- *
- * @example Pattern B: Object builders
- * ```typescript
- * attrs.user({ id: '123', email: 'user@example.com' })
- * attrs.http.server({ method: 'GET', route: '/users/:id', statusCode: 200 })
- * attrs.db.client({ system: 'postgresql', operation: 'SELECT', collectionName: 'users' })
- * ```
- */
-
-import {
-  UserAttributes,
-  SessionAttributes,
-  DeviceAttributes,
-  HTTPAttributes,
-  DBAttributes,
-  ServiceAttributes,
-  NetworkAttributes,
-  ServerAddressAttributes,
-  URLAttributes,
-  ErrorAttributes,
-  ExceptionAttributes,
-  ProcessAttributes,
-  ThreadAttributes,
-  ContainerAttributes,
-  K8sAttributes,
-  CloudAttributes,
-  FaaSAttributes,
-  FeatureFlagAttributes,
-  MessagingAttributes,
-  RPCAttributes,
-  GraphQLAttributes,
-  OTelAttributes,
-  CodeAttributes,
-  TLSAttributes,
-} from './registry';
-
-import type {
-  UserAttrs,
-  SessionAttrs,
-  DeviceAttrs,
-  HTTPServerAttrs,
-  HTTPClientAttrs,
-  DBAttrs,
-  ServiceAttrs,
-  NetworkAttrs,
-  ErrorAttrs,
-  MessagingAttrs,
-  CloudAttrs,
-  ServerAddressAttrs,
-  URLAttrs,
-  ProcessAttrs,
-  ContainerAttrs,
-  ExceptionAttrs,
-} from './types';
-
-export const attrs = {
-  user: {
-    id: (value: string) => ({ [UserAttributes.id]: value }),
-    email: (value: string) => ({ [UserAttributes.email]: value }),
-    name: (value: string) => ({ [UserAttributes.name]: value }),
-    fullName: (value: string) => ({ [UserAttributes.fullName]: value }),
-    hash: (value: string) => ({ [UserAttributes.hash]: value }),
-    roles: (value: string[]) => ({ [UserAttributes.roles]: value }),
-
-    data: (data: UserAttrs) => {
-      const result: Record<string, unknown> = {};
-      if (data.id !== undefined) result[UserAttributes.id] = data.id;
-      if (data.email !== undefined) result[UserAttributes.email] = data.email;
-      if (data.name !== undefined) result[UserAttributes.name] = data.name;
-      if (data.fullName !== undefined)
-        result[UserAttributes.fullName] = data.fullName;
-      if (data.hash !== undefined) result[UserAttributes.hash] = data.hash;
-      if (data.roles !== undefined) result[UserAttributes.roles] = data.roles;
-      return result;
-    },
-  },
-
-  session: {
-    id: (value: string) => ({ [SessionAttributes.id]: value }),
-    previousId: (value: string) => ({ [SessionAttributes.previousId]: value }),
-
-    data: (data: SessionAttrs) => {
-      const result: Record<string, unknown> = {};
-      if (data.id !== undefined) result[SessionAttributes.id] = data.id;
-      if (data.previousId !== undefined)
-        result[SessionAttributes.previousId] = data.previousId;
-      return result;
-    },
-  },
-
-  device: {
-    id: (value: string) => ({ [DeviceAttributes.id]: value }),
-    manufacturer: (value: string) => ({
-      [DeviceAttributes.manufacturer]: value,
-    }),
-    modelIdentifier: (value: string) => ({
-      [DeviceAttributes.modelIdentifier]: value,
-    }),
-    modelName: (value: string) => ({ [DeviceAttributes.modelName]: value }),
-
-    data: (data: DeviceAttrs) => {
-      const result: Record<string, unknown> = {};
-      if (data.id !== undefined) result[DeviceAttributes.id] = data.id;
-      if (data.manufacturer !== undefined)
-        result[DeviceAttributes.manufacturer] = data.manufacturer;
-      if (data.modelIdentifier !== undefined)
-        result[DeviceAttributes.modelIdentifier] = data.modelIdentifier;
-      if (data.modelName !== undefined)
-        result[DeviceAttributes.modelName] = data.modelName;
-      return result;
-    },
-  },
-
-  http: {
-    request: {
-      method: (value: string) => ({ [HTTPAttributes.requestMethod]: value }),
-      methodOriginal: (value: string) => ({
-        [HTTPAttributes.requestMethodOriginal]: value,
-      }),
-      resendCount: (value: number) => ({
-        [HTTPAttributes.requestResendCount]: value,
-      }),
-      size: (value: number) => ({ [HTTPAttributes.requestSize]: value }),
-      bodySize: (value: number) => ({
-        [HTTPAttributes.requestBodySize]: value,
-      }),
-    },
-
-    response: {
-      statusCode: (value: number) => ({
-        [HTTPAttributes.responseStatusCode]: value,
-      }),
-      size: (value: number) => ({ [HTTPAttributes.responseSize]: value }),
-      bodySize: (value: number) => ({
-        [HTTPAttributes.responseBodySize]: value,
-      }),
-    },
-
-    route: (value: string) => ({ [HTTPAttributes.route]: value }),
-    connectionState: (value: string) => ({
-      [HTTPAttributes.connectionState]: value,
-    }),
-
-    server: (data: HTTPServerAttrs) => {
-      const result: Record<string, unknown> = {};
-      if (data.method !== undefined)
-        result[HTTPAttributes.requestMethod] = data.method;
-      if (data.route !== undefined) result[HTTPAttributes.route] = data.route;
-      if (data.statusCode !== undefined)
-        result[HTTPAttributes.responseStatusCode] = data.statusCode;
-      if (data.bodySize !== undefined)
-        result[HTTPAttributes.requestBodySize] = data.bodySize;
-      if (data.requestSize !== undefined)
-        result[HTTPAttributes.requestSize] = data.requestSize;
-      if (data.responseSize !== undefined)
-        result[HTTPAttributes.responseSize] = data.responseSize;
-      if (data.resendCount !== undefined)
-        result[HTTPAttributes.requestResendCount] = data.resendCount;
-      return result;
-    },
-
-    client: (data: HTTPClientAttrs) => {
-      const result: Record<string, unknown> = {};
-      if (data.method !== undefined)
-        result[HTTPAttributes.requestMethod] = data.method;
-      if (data.url !== undefined) result[HTTPAttributes.route] = data.url;
-      if (data.statusCode !== undefined)
-        result[HTTPAttributes.responseStatusCode] = data.statusCode;
-      return result;
-    },
-  },
-
-  db: {
-    client: {
-      system: (value: string) => ({ [DBAttributes.systemName]: value }),
-      operation: (value: string) => ({ [DBAttributes.operationName]: value }),
-      collectionName: (value: string) => ({
-        [DBAttributes.collectionName]: value,
-      }),
-      namespace: (value: string) => ({ [DBAttributes.namespace]: value }),
-      statement: (value: string) => ({ [DBAttributes.statement]: value }),
-      querySummary: (value: string) => ({ [DBAttributes.querySummary]: value }),
-      queryText: (value: string) => ({ [DBAttributes.queryText]: value }),
-      responseStatus: (value: string | number) => ({
-        [DBAttributes.responseStatusCode]: value,
-      }),
-      rowsReturned: (value: number) => ({
-        [DBAttributes.responseReturnedRows]: value,
-      }),
-
-      data: (data: DBAttrs) => {
-        const result: Record<string, unknown> = {};
-        if (data.system !== undefined)
-          result[DBAttributes.systemName] = data.system;
-        if (data.operation !== undefined)
-          result[DBAttributes.operationName] = data.operation;
-        if (data.collectionName !== undefined)
-          result[DBAttributes.collectionName] = data.collectionName;
-        // 'name' maps to db.namespace (db.name is deprecated per OTel semantic conventions)
-        if (data.name !== undefined) result[DBAttributes.namespace] = data.name;
-        // 'namespace' takes precedence over 'name' if both are provided
-        if (data.namespace !== undefined)
-          result[DBAttributes.namespace] = data.namespace;
-        if (data.statement !== undefined)
-          result[DBAttributes.statement] = data.statement;
-        if (data.querySummary !== undefined)
-          result[DBAttributes.querySummary] = data.querySummary;
-        if (data.queryText !== undefined)
-          result[DBAttributes.queryText] = data.queryText;
-        if (data.responseStatus !== undefined)
-          result[DBAttributes.responseStatusCode] = data.responseStatus;
-        if (data.rowsReturned !== undefined)
-          result[DBAttributes.responseReturnedRows] = data.rowsReturned;
-        return result;
-      },
-    },
-  },
-
-  service: {
-    name: (value: string) => ({ [ServiceAttributes.name]: value }),
-    instance: (value: string) => ({ [ServiceAttributes.instance]: value }),
-    version: (value: string) => ({ [ServiceAttributes.version]: value }),
-
-    data: (data: ServiceAttrs) => {
-      const result: Record<string, unknown> = {};
-      if (data.name !== undefined) result[ServiceAttributes.name] = data.name;
-      if (data.instance !== undefined)
-        result[ServiceAttributes.instance] = data.instance;
-      if (data.version !== undefined)
-        result[ServiceAttributes.version] = data.version;
-      return result;
-    },
-  },
-
-  network: {
-    peerAddress: (value: string) => ({
-      [NetworkAttributes.peerAddress]: value,
-    }),
-    peerPort: (value: number) => ({ [NetworkAttributes.peerPort]: value }),
-    transport: (value: string) => ({ [NetworkAttributes.transport]: value }),
-    protocolName: (value: string) => ({
-      [NetworkAttributes.protocolName]: value,
-    }),
-    protocolVersion: (value: string) => ({
-      [NetworkAttributes.protocolVersion]: value,
-    }),
-
-    data: (data: NetworkAttrs) => {
-      const result: Record<string, unknown> = {};
-      if (data.peerAddress !== undefined)
-        result[NetworkAttributes.peerAddress] = data.peerAddress;
-      if (data.peerPort !== undefined)
-        result[NetworkAttributes.peerPort] = data.peerPort;
-      if (data.transport !== undefined)
-        result[NetworkAttributes.transport] = data.transport;
-      if (data.protocolName !== undefined)
-        result[NetworkAttributes.protocolName] = data.protocolName;
-      if (data.protocolVersion !== undefined)
-        result[NetworkAttributes.protocolVersion] = data.protocolVersion;
-      return result;
-    },
-  },
-
-  server: {
-    address: (value: string) => ({ [ServerAddressAttributes.address]: value }),
-    port: (value: number) => ({ [ServerAddressAttributes.port]: value }),
-    socketAddress: (value: string) => ({
-      [ServerAddressAttributes.socketAddress]: value,
-    }),
-
-    data: (data: ServerAddressAttrs) => {
-      const result: Record<string, unknown> = {};
-      if (data.address !== undefined)
-        result[ServerAddressAttributes.address] = data.address;
-      if (data.port !== undefined)
-        result[ServerAddressAttributes.port] = data.port;
-      if (data.socketAddress !== undefined)
-        result[ServerAddressAttributes.socketAddress] = data.socketAddress;
-      return result;
-    },
-  },
-
-  url: {
-    scheme: (value: string) => ({ [URLAttributes.scheme]: value }),
-    full: (value: string) => ({ [URLAttributes.full]: value }),
-    path: (value: string) => ({ [URLAttributes.path]: value }),
-    query: (value: string) => ({ [URLAttributes.query]: value }),
-    fragment: (value: string) => ({ [URLAttributes.fragment]: value }),
-
-    data: (data: URLAttrs) => {
-      const result: Record<string, unknown> = {};
-      if (data.scheme !== undefined) result[URLAttributes.scheme] = data.scheme;
-      if (data.full !== undefined) result[URLAttributes.full] = data.full;
-      if (data.path !== undefined) result[URLAttributes.path] = data.path;
-      if (data.query !== undefined) result[URLAttributes.query] = data.query;
-      if (data.fragment !== undefined)
-        result[URLAttributes.fragment] = data.fragment;
-      return result;
-    },
-  },
-
-  error: {
-    type: (value: string) => ({ [ErrorAttributes.type]: value }),
-    message: (value: string) => ({ [ErrorAttributes.message]: value }),
-    stackTrace: (value: string) => ({ [ErrorAttributes.stackTrace]: value }),
-    code: (value: string | number) => ({ [ErrorAttributes.code]: value }),
-
-    data: (data: ErrorAttrs) => {
-      const result: Record<string, unknown> = {};
-      if (data.type !== undefined) result[ErrorAttributes.type] = data.type;
-      if (data.message !== undefined)
-        result[ErrorAttributes.message] = data.message;
-      if (data.stackTrace !== undefined)
-        result[ErrorAttributes.stackTrace] = data.stackTrace;
-      if (data.code !== undefined) result[ErrorAttributes.code] = data.code;
-      return result;
-    },
-  },
-
-  exception: {
-    escaped: (value: boolean) => ({ [ExceptionAttributes.escaped]: value }),
-    message: (value: string) => ({ [ExceptionAttributes.message]: value }),
-    stackTrace: (value: string) => ({
-      [ExceptionAttributes.stackTrace]: value,
-    }),
-    type: (value: string) => ({ [ExceptionAttributes.type]: value }),
-    moduleName: (value: string) => ({
-      [ExceptionAttributes.moduleName]: value,
-    }),
-
-    data: (data: ExceptionAttrs) => {
-      const result: Record<string, unknown> = {};
-      if (data.escaped !== undefined)
-        result[ExceptionAttributes.escaped] = data.escaped;
-      if (data.message !== undefined)
-        result[ExceptionAttributes.message] = data.message;
-      if (data.stackTrace !== undefined)
-        result[ExceptionAttributes.stackTrace] = data.stackTrace;
-      if (data.type !== undefined) result[ExceptionAttributes.type] = data.type;
-      if (data.moduleName !== undefined)
-        result[ExceptionAttributes.moduleName] = data.moduleName;
-      return result;
-    },
-  },
-
-  process: {
-    pid: (value: number) => ({ [ProcessAttributes.pid]: value }),
-    executablePath: (value: string) => ({
-      [ProcessAttributes.executablePath]: value,
-    }),
-    command: (value: string) => ({ [ProcessAttributes.command]: value }),
-    owner: (value: string) => ({ [ProcessAttributes.owner]: value }),
-
-    data: (data: ProcessAttrs) => {
-      const result: Record<string, unknown> = {};
-      if (data.pid !== undefined) result[ProcessAttributes.pid] = data.pid;
-      if (data.executablePath !== undefined)
-        result[ProcessAttributes.executablePath] = data.executablePath;
-      if (data.command !== undefined)
-        result[ProcessAttributes.command] = data.command;
-      if (data.owner !== undefined)
-        result[ProcessAttributes.owner] = data.owner;
-      return result;
-    },
-  },
-
-  thread: {
-    id: (value: number) => ({ [ThreadAttributes.id]: value }),
-    name: (value: string) => ({ [ThreadAttributes.name]: value }),
-  },
-
-  container: {
-    id: (value: string) => ({ [ContainerAttributes.id]: value }),
-    name: (value: string) => ({ [ContainerAttributes.name]: value }),
-    image: (value: string) => ({ [ContainerAttributes.image]: value }),
-    tag: (value: string) => ({ [ContainerAttributes.tag]: value }),
-
-    data: (data: ContainerAttrs) => {
-      const result: Record<string, unknown> = {};
-      if (data.id !== undefined) result[ContainerAttributes.id] = data.id;
-      if (data.name !== undefined) result[ContainerAttributes.name] = data.name;
-      if (data.image !== undefined)
-        result[ContainerAttributes.image] = data.image;
-      if (data.tag !== undefined) result[ContainerAttributes.tag] = data.tag;
-      return result;
-    },
-  },
-
-  k8s: {
-    podName: (value: string) => ({ [K8sAttributes.podName]: value }),
-    namespaceName: (value: string) => ({
-      [K8sAttributes.namespaceName]: value,
-    }),
-    deploymentName: (value: string) => ({
-      [K8sAttributes.deploymentName]: value,
-    }),
-    state: (value: string) => ({ [K8sAttributes.state]: value }),
-  },
-
-  cloud: {
-    provider: (value: string) => ({ [CloudAttributes.provider]: value }),
-    accountId: (value: string) => ({ [CloudAttributes.accountId]: value }),
-    region: (value: string) => ({ [CloudAttributes.region]: value }),
-    availabilityZone: (value: string) => ({
-      [CloudAttributes.availabilityZone]: value,
-    }),
-    platform: (value: string) => ({ [CloudAttributes.platform]: value }),
-
-    data: (data: CloudAttrs) => {
-      const result: Record<string, unknown> = {};
-      if (data.provider !== undefined)
-        result[CloudAttributes.provider] = data.provider;
-      if (data.accountId !== undefined)
-        result[CloudAttributes.accountId] = data.accountId;
-      if (data.region !== undefined)
-        result[CloudAttributes.region] = data.region;
-      if (data.availabilityZone !== undefined)
-        result[CloudAttributes.availabilityZone] = data.availabilityZone;
-      if (data.platform !== undefined)
-        result[CloudAttributes.platform] = data.platform;
-      return result;
-    },
-  },
-
-  faas: {
-    name: (value: string) => ({ [FaaSAttributes.name]: value }),
-    version: (value: string) => ({ [FaaSAttributes.version]: value }),
-    instance: (value: string) => ({ [FaaSAttributes.instance]: value }),
-    execution: (value: string) => ({ [FaaSAttributes.execution]: value }),
-    coldstart: (value: boolean) => ({ [FaaSAttributes.coldstart]: value }),
-  },
-
-  featureFlag: {
-    key: (value: string) => ({ [FeatureFlagAttributes.key]: value }),
-    provider: (value: string) => ({ [FeatureFlagAttributes.provider]: value }),
-    variant: (value: string) => ({ [FeatureFlagAttributes.variant]: value }),
-  },
-
-  messaging: {
-    system: (value: string) => ({ [MessagingAttributes.system]: value }),
-    destination: (value: string) => ({
-      [MessagingAttributes.destination]: value,
-    }),
-    operation: (value: 'publish' | 'receive' | 'process') => ({
-      [MessagingAttributes.operation]: value,
-    }),
-    messageId: (value: string) => ({ [MessagingAttributes.messageId]: value }),
-    conversationId: (value: string) => ({
-      [MessagingAttributes.conversationId]: value,
-    }),
-
-    data: (data: MessagingAttrs) => {
-      const result: Record<string, unknown> = {};
-      if (data.system !== undefined)
-        result[MessagingAttributes.system] = data.system;
-      if (data.destination !== undefined)
-        result[MessagingAttributes.destination] = data.destination;
-      if (data.operation !== undefined)
-        result[MessagingAttributes.operation] = data.operation;
-      if (data.messageId !== undefined)
-        result[MessagingAttributes.messageId] = data.messageId;
-      if (data.conversationId !== undefined)
-        result[MessagingAttributes.conversationId] = data.conversationId;
-      return result;
-    },
-  },
-
-  // GenAI/LLM attribute builders moved to the `autotel-genai` package
-  // (canonical `gen_ai.*` semantic conventions).
-
-  rpc: {
-    system: (value: string) => ({ [RPCAttributes.system]: value }),
-    service: (value: string) => ({ [RPCAttributes.service]: value }),
-    method: (value: string) => ({ [RPCAttributes.method]: value }),
-    grpcStatusCode: (value: number) => ({
-      [RPCAttributes.grpcStatusCode]: value,
-    }),
-  },
-
-  graphql: {
-    document: (value: string) => ({ [GraphQLAttributes.document]: value }),
-    operationName: (value: string) => ({
-      [GraphQLAttributes.operationName]: value,
-    }),
-    operationType: (value: 'query' | 'mutation' | 'subscription') => ({
-      [GraphQLAttributes.operationType]: value,
-    }),
-  },
-
-  otel: {
-    libraryName: (value: string) => ({ [OTelAttributes.libraryName]: value }),
-    libraryVersion: (value: string) => ({
-      [OTelAttributes.libraryVersion]: value,
-    }),
-    statusCode: (value: string) => ({ [OTelAttributes.statusCode]: value }),
-  },
-
-  code: {
-    namespace: (value: string) => ({ [CodeAttributes.namespace]: value }),
-    filepath: (value: string) => ({ [CodeAttributes.filepath]: value }),
-    function: (value: string) => ({ [CodeAttributes.function]: value }),
-    class: (value: string) => ({ [CodeAttributes.class]: value }),
-    method: (value: string) => ({ [CodeAttributes.method]: value }),
-    column: (value: string) => ({ [CodeAttributes.column]: value }),
-    lineNumber: (value: number) => ({ [CodeAttributes.lineNumber]: value }),
-    repository: (value: string) => ({ [CodeAttributes.repository]: value }),
-    revision: (value: string) => ({ [CodeAttributes.revision]: value }),
-  },
-
-  tls: {
-    protocolVersion: (value: string) => ({
-      [TLSAttributes.protocolVersion]: value,
-    }),
-    cipher: (value: string) => ({ [TLSAttributes.cipher]: value }),
-    curveName: (value: string) => ({ [TLSAttributes.curveName]: value }),
-    resumed: (value: boolean) => ({ [TLSAttributes.resumed]: value }),
-  },
-} as const;