autotel-edge 3.0.0

package/src/core/context.ts

@@ -0,0 +1,224 @@
+/**
+ * AsyncLocalStorage-based context manager for edge environments
+ *
+ * Copyright The OpenTelemetry Authors
+ * Licensed under the Apache License, Version 2.0
+ */
+
+import type { ContextManager, Context } from '@opentelemetry/api';
+import { ROOT_CONTEXT } from '@opentelemetry/api';
+
+//@ts-ignore - node:async_hooks available in CF Workers with nodejs_compat
+import { AsyncLocalStorage } from 'node:async_hooks';
+//@ts-ignore
+import { EventEmitter } from 'node:events';
+
+type Func<T> = (...args: unknown[]) => T;
+
+/**
+ * Store a map for each event of all original listeners and their "patched"
+ * version. So when a listener is removed by the user, the corresponding
+ * patched function will be also removed.
+ */
+interface PatchMap {
+  [name: string]: WeakMap<Func<void>, Func<void>>;
+}
+
+const ADD_LISTENER_METHODS = [
+  'addListener' as const,
+  'on' as const,
+  'once' as const,
+  'prependListener' as const,
+  'prependOnceListener' as const,
+];
+
+abstract class AbstractAsyncHooksContextManager implements ContextManager {
+  abstract active(): Context;
+
+  abstract with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(
+    context: Context,
+    fn: F,
+    thisArg?: ThisParameterType<F>,
+    ...args: A
+  ): ReturnType<F>;
+
+  abstract enable(): this;
+
+  abstract disable(): this;
+
+  /**
+   * Binds a context to the target function or event emitter
+   */
+  bind<T>(context: Context, target: T): T {
+    if (target instanceof EventEmitter) {
+      return this._bindEventEmitter(context, target);
+    }
+
+    if (typeof target === 'function') {
+      return this._bindFunction(context, target);
+    }
+    return target;
+  }
+
+  private _bindFunction<T extends Function>(context: Context, target: T): T {
+    const manager = this;
+    const contextWrapper = function (this: never, ...args: unknown[]) {
+      return manager.with(context, () => target.apply(this, args));
+    };
+    Object.defineProperty(contextWrapper, 'length', {
+      enumerable: false,
+      configurable: true,
+      writable: false,
+      value: target.length,
+    });
+    return contextWrapper as any;
+  }
+
+  /**
+   * By default, EventEmitter calls callbacks with their context, which we do
+   * not want. Instead we bind a specific context to all callbacks.
+   */
+  private _bindEventEmitter<T extends EventEmitter>(
+    context: Context,
+    ee: T,
+  ): T {
+    const map = this._getPatchMap(ee);
+    if (map !== undefined) return ee;
+    this._createPatchMap(ee);
+
+    // Patch methods that add a listener to propagate context
+    for (const methodName of ADD_LISTENER_METHODS) {
+      if (ee[methodName] === undefined) continue;
+      ee[methodName] = this._patchAddListener(ee, ee[methodName], context);
+    }
+
+    // Patch methods that remove a listener
+    if (typeof ee.removeListener === 'function') {
+      ee.removeListener = this._patchRemoveListener(ee, ee.removeListener);
+    }
+    if (typeof ee.off === 'function') {
+      ee.off = this._patchRemoveListener(ee, ee.off);
+    }
+
+    // Patch method that removes all listeners
+    if (typeof ee.removeAllListeners === 'function') {
+      ee.removeAllListeners = this._patchRemoveAllListeners(
+        ee,
+        ee.removeAllListeners,
+      );
+    }
+    return ee;
+  }
+
+  private _patchRemoveListener(ee: EventEmitter, original: Function) {
+    const contextManager = this;
+    return function (this: never, event: string, listener: Func<void>) {
+      const events = contextManager._getPatchMap(ee)?.[event];
+      if (events === undefined) {
+        return original.call(this, event, listener);
+      }
+      const patchedListener = events.get(listener);
+      return original.call(this, event, patchedListener || listener);
+    };
+  }
+
+  private _patchRemoveAllListeners(ee: EventEmitter, original: Function) {
+    const contextManager = this;
+    return function (this: never, event: string) {
+      const map = contextManager._getPatchMap(ee);
+      if (map !== undefined) {
+        if (arguments.length === 0) {
+          contextManager._createPatchMap(ee);
+        } else if (map[event] !== undefined) {
+          delete map[event];
+        }
+      }
+      return Reflect.apply(original, this, arguments);
+    };
+  }
+
+  private _patchAddListener(
+    ee: EventEmitter,
+    original: Function,
+    context: Context,
+  ) {
+    const contextManager = this;
+    return function (this: never, event: string, listener: Func<void>) {
+      /**
+       * This check prevents double-wrapping the listener.
+       * The implementation for ee.once wraps the listener and calls ee.on.
+       * Without this check, we would wrap that wrapped listener.
+       */
+      if (contextManager._wrapped) {
+        return original.call(this, event, listener);
+      }
+      let map = contextManager._getPatchMap(ee);
+      if (map === undefined) {
+        map = contextManager._createPatchMap(ee);
+      }
+      let listeners = map[event];
+      if (listeners === undefined) {
+        listeners = new WeakMap();
+        map[event] = listeners;
+      }
+      const patchedListener = contextManager.bind(context, listener);
+      // Store a weak reference of the user listener to ours
+      listeners.set(listener, patchedListener);
+
+      contextManager._wrapped = true;
+      try {
+        return original.call(this, event, patchedListener);
+      } finally {
+        contextManager._wrapped = false;
+      }
+    };
+  }
+
+  private _createPatchMap(ee: EventEmitter): PatchMap {
+    const map = Object.create(null);
+    (ee as any)[this._kOtListeners] = map;
+    return map;
+  }
+
+  private _getPatchMap(ee: EventEmitter): PatchMap | undefined {
+    return (ee as never)[this._kOtListeners];
+  }
+
+  private readonly _kOtListeners = Symbol('OtListeners');
+  private _wrapped = false;
+}
+
+/**
+ * AsyncLocalStorage-based context manager for edge runtimes
+ */
+export class AsyncLocalStorageContextManager extends AbstractAsyncHooksContextManager {
+  private _asyncLocalStorage: AsyncLocalStorage<Context>;
+
+  constructor() {
+    super();
+    this._asyncLocalStorage = new AsyncLocalStorage();
+  }
+
+  active(): Context {
+    return this._asyncLocalStorage.getStore() ?? ROOT_CONTEXT;
+  }
+
+  with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(
+    context: Context,
+    fn: F,
+    thisArg?: ThisParameterType<F>,
+    ...args: A
+  ): ReturnType<F> {
+    const cb = thisArg == null ? fn : fn.bind(thisArg);
+    return this._asyncLocalStorage.run(context, cb as never, ...args);
+  }
+
+  enable(): this {
+    return this;
+  }
+
+  disable(): this {
+    this._asyncLocalStorage.disable();
+    return this;
+  }
+}

package/src/core/exporter.ts

@@ -0,0 +1,99 @@
+/**
+ * Lightweight OTLP exporter for edge environments
+ * Ported and adapted from @microlabs/
+ *
+ * This exporter is much smaller than the standard @opentelemetry/exporter-trace-otlp-http
+ * because it uses fetch() directly instead of Node.js http/https modules.
+ */
+
+import type { ExportResult } from '@opentelemetry/core';
+import { ExportResultCode } from '@opentelemetry/core';
+import { OTLPExporterError } from '@opentelemetry/otlp-exporter-base';
+import { JsonTraceSerializer } from '@opentelemetry/otlp-transformer';
+import type { SpanExporter } from '@opentelemetry/sdk-trace-base';
+import type { OTLPExporterConfig } from '../types';
+
+// Version is injected at build time via tsup define
+// This avoids runtime filesystem access which isn't available in edge environments
+const PACKAGE_VERSION = process.env.AUTOLEMETRY_EDGE_VERSION || '0.1.1';
+
+const defaultHeaders: Record<string, string> = {
+  accept: 'application/json',
+  'content-type': 'application/json',
+  'user-agent': `autotel-edge v${PACKAGE_VERSION}`,
+};
+
+/**
+ * Minimal OTLP exporter using fetch()
+ */
+export class OTLPExporter implements SpanExporter {
+  private headers: Record<string, string>;
+  private url: string;
+
+  constructor(config: OTLPExporterConfig) {
+    this.url = config.url;
+    this.headers = Object.assign({}, defaultHeaders, config.headers);
+  }
+
+  export(items: any[], resultCallback: (result: ExportResult) => void): void {
+    this._export(items)
+      .then(() => {
+        resultCallback({ code: ExportResultCode.SUCCESS });
+      })
+      .catch((error) => {
+        resultCallback({ code: ExportResultCode.FAILED, error });
+      });
+  }
+
+  private _export(items: any[]): Promise<unknown> {
+    return new Promise<void>((resolve, reject) => {
+      try {
+        this.send(items, resolve, reject);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  send(
+    items: any[],
+    onSuccess: () => void,
+    onError: (error: OTLPExporterError) => void,
+  ): void {
+    const decoder = new TextDecoder();
+    const exportMessage = JsonTraceSerializer.serializeRequest(items);
+
+    const body = decoder.decode(exportMessage);
+    const params: RequestInit = {
+      method: 'POST',
+      headers: this.headers,
+      body,
+    };
+
+    fetch(this.url, params)
+      .then((response) => {
+        if (response.ok) {
+          onSuccess();
+        } else {
+          onError(
+            new OTLPExporterError(
+              `Exporter received a statusCode: ${response.status}`,
+            ),
+          );
+        }
+      })
+      .catch((error) => {
+        onError(
+          new OTLPExporterError(
+            `Exception during export: ${error.toString()}`,
+            error.code,
+            error.stack,
+          ),
+        );
+      });
+  }
+
+  async shutdown(): Promise<void> {
+    // No-op for edge environments
+  }
+}

package/src/core/provider.ts

@@ -0,0 +1,45 @@
+/**
+ * Tracer provider for edge environments
+ */
+
+import { trace } from '@opentelemetry/api';
+import type { Resource } from '@opentelemetry/resources';
+import type { SpanProcessor, TracerConfig } from '@opentelemetry/sdk-trace-base';
+import { WorkerTracer } from './tracer';
+import { AsyncLocalStorageContextManager } from './context';
+
+/**
+ * WorkerTracerProvider - Registers tracer globally
+ */
+export class WorkerTracerProvider {
+  private tracer: WorkerTracer;
+  private contextManager: AsyncLocalStorageContextManager;
+
+  constructor(spanProcessors: SpanProcessor[], resource: Resource) {
+    this.tracer = new WorkerTracer(spanProcessors, resource);
+    this.contextManager = new AsyncLocalStorageContextManager();
+  }
+
+  /**
+   * Get the tracer instance
+   */
+  getTracer(_name: string, _version?: string, _config?: TracerConfig): WorkerTracer {
+    return this.tracer;
+  }
+
+  /**
+   * Register this provider as the global tracer
+   */
+  register(): void {
+    // Enable context manager
+    this.contextManager.enable();
+
+    // Set tracer provider
+    const provider = {
+      getTracer: (_name: string, _version?: string) => this.tracer,
+    };
+
+    // @ts-ignore - OTel types
+    trace.setGlobalTracerProvider(provider);
+  }
+}

package/src/core/span.ts

@@ -0,0 +1,222 @@
+/**
+ * Lightweight Span implementation for edge environments
+ */
+
+import type {
+  Attributes,
+  AttributeValue,
+  Exception,
+  HrTime,
+  Link,
+  Span,
+  SpanContext,
+  SpanKind,
+  SpanStatus,
+  SpanStatusCode,
+  TimeInput,
+} from '@opentelemetry/api';
+import {
+  hrTimeDuration,
+  type InstrumentationScope,
+  isAttributeValue,
+  isTimeInput,
+  sanitizeAttributes,
+} from '@opentelemetry/core';
+import type { Resource } from '@opentelemetry/resources';
+import type { ReadableSpan, TimedEvent } from '@opentelemetry/sdk-trace-base';
+import { SEMATTRS_EXCEPTION_MESSAGE, SEMATTRS_EXCEPTION_STACKTRACE, SEMATTRS_EXCEPTION_TYPE } from '@opentelemetry/semantic-conventions';
+
+type OnSpanEnd = (span: Span) => void;
+
+interface SpanInit {
+  attributes: unknown;
+  name: string;
+  onEnd: OnSpanEnd;
+  resource: Resource;
+  spanContext: SpanContext;
+  parentSpanContext?: SpanContext;
+  links?: Link[];
+  parentSpanId?: string;
+  spanKind?: SpanKind;
+  startTime?: TimeInput;
+}
+
+function transformExceptionAttributes(exception: Exception): Attributes {
+  const attributes: Attributes = {};
+  if (typeof exception === 'string') {
+    attributes[SEMATTRS_EXCEPTION_MESSAGE] = exception;
+  } else {
+    if (exception.code) {
+      attributes[SEMATTRS_EXCEPTION_TYPE] = exception.code.toString();
+    } else if (exception.name) {
+      attributes[SEMATTRS_EXCEPTION_TYPE] = exception.name;
+    }
+    if (exception.message) {
+      attributes[SEMATTRS_EXCEPTION_MESSAGE] = exception.message;
+    }
+    if (exception.stack) {
+      attributes[SEMATTRS_EXCEPTION_STACKTRACE] = exception.stack;
+    }
+  }
+  return attributes;
+}
+
+function millisToHr(millis: number): HrTime {
+  return [Math.trunc(millis / 1000), (millis % 1000) * 1e6];
+}
+
+function getHrTime(input?: TimeInput): HrTime {
+  const now = Date.now();
+  if (!input) {
+    return millisToHr(now);
+  } else if (input instanceof Date) {
+    return millisToHr(input.getTime());
+  } else if (typeof input === 'number') {
+    return millisToHr(input);
+  } else if (Array.isArray(input)) {
+    return input;
+  }
+
+  const v: never = input;
+  throw new Error(`unreachable value: ${JSON.stringify(v)}`);
+}
+
+// Previously exported from OTel, now private
+function isAttributeKey(key: unknown): key is string {
+  return typeof key === 'string' && key.length > 0;
+}
+
+/**
+ * Lightweight Span implementation for edge runtimes
+ */
+export class SpanImpl implements Span, ReadableSpan {
+  name: string;
+  private readonly _spanContext: SpanContext;
+  private readonly onEnd: OnSpanEnd;
+  readonly parentSpanId?: string;
+  readonly parentSpanContext?: SpanContext | undefined;
+  readonly kind: SpanKind;
+  readonly attributes: Attributes;
+  status: SpanStatus = {
+    code: 0 as SpanStatusCode, // SpanStatusCode.UNSET
+  };
+  endTime: HrTime = [0, 0];
+  private _duration: HrTime = [0, 0];
+  readonly startTime: HrTime;
+  readonly events: TimedEvent[] = [];
+  readonly links: Link[];
+  readonly resource: Resource;
+  instrumentationScope: InstrumentationScope = {
+    name: 'autotel-edge',
+  };
+  private _ended: boolean = false;
+  private _droppedAttributesCount: number = 0;
+  private _droppedEventsCount: number = 0;
+  private _droppedLinksCount: number = 0;
+
+  constructor(init: SpanInit) {
+    this.name = init.name;
+    this._spanContext = init.spanContext;
+    this.parentSpanId = init.parentSpanId;
+    this.parentSpanContext = init.parentSpanContext;
+    this.kind = init.spanKind || (0 as SpanKind); // SpanKind.INTERNAL
+    this.attributes = sanitizeAttributes(init.attributes);
+    this.startTime = getHrTime(init.startTime);
+    this.links = init.links || [];
+    this.resource = init.resource;
+    this.onEnd = init.onEnd;
+  }
+
+  addLink(link: Link): this {
+    this.links.push(link);
+    return this;
+  }
+
+  addLinks(links: Link[]): this {
+    this.links.push(...links);
+    return this;
+  }
+
+  spanContext(): SpanContext {
+    return this._spanContext;
+  }
+
+  setAttribute(key: string, value?: AttributeValue): this {
+    if (isAttributeKey(key) && isAttributeValue(value)) {
+      this.attributes[key] = value;
+    }
+    return this;
+  }
+
+  setAttributes(attributes: Attributes): this {
+    for (const [key, value] of Object.entries(attributes)) {
+      this.setAttribute(key, value);
+    }
+    return this;
+  }
+
+  addEvent(
+    name: string,
+    attributesOrStartTime?: Attributes | TimeInput,
+    startTime?: TimeInput,
+  ): this {
+    if (isTimeInput(attributesOrStartTime)) {
+      startTime = attributesOrStartTime;
+      attributesOrStartTime = undefined;
+    }
+
+    const attributes = sanitizeAttributes(attributesOrStartTime);
+    const time = getHrTime(startTime);
+    this.events.push({ name, attributes, time });
+    return this;
+  }
+
+  setStatus(status: SpanStatus): this {
+    this.status = status;
+    return this;
+  }
+
+  updateName(name: string): this {
+    this.name = name;
+    return this;
+  }
+
+  end(endTime?: TimeInput): void {
+    if (this._ended) {
+      return;
+    }
+    this._ended = true;
+    this.endTime = getHrTime(endTime);
+    this._duration = hrTimeDuration(this.startTime, this.endTime);
+    this.onEnd(this);
+  }
+
+  isRecording(): boolean {
+    return !this._ended;
+  }
+
+  recordException(exception: Exception, time?: TimeInput): void {
+    const attributes = transformExceptionAttributes(exception);
+    this.addEvent('exception', attributes, time);
+  }
+
+  get duration(): HrTime {
+    return this._duration;
+  }
+
+  get ended(): boolean {
+    return this._ended;
+  }
+
+  get droppedAttributesCount(): number {
+    return this._droppedAttributesCount;
+  }
+
+  get droppedEventsCount(): number {
+    return this._droppedEventsCount;
+  }
+
+  get droppedLinksCount(): number {
+    return this._droppedLinksCount;
+  }
+}