autotel-edge 3.0.0

package/dist/index.d.ts

@@ -0,0 +1,326 @@
+import { Span, SpanContext, SpanKind, Attributes, SpanStatus, HrTime, Link, TimeInput, AttributeValue, Exception, Tracer, SpanOptions as SpanOptions$1, Context, ContextManager, SpanStatusCode } from '@opentelemetry/api';
+export { Context, Span, SpanContext, Tracer, context, propagation } from '@opentelemetry/api';
+import { InstrumentationScope, ExportResult } from '@opentelemetry/core';
+import { Resource } from '@opentelemetry/resources';
+import { ReadableSpan, TimedEvent, SpanProcessor, SpanExporter, TracerConfig, Sampler } from '@opentelemetry/sdk-trace-base';
+export { ReadableSpan } from '@opentelemetry/sdk-trace-base';
+import { OTLPExporterError } from '@opentelemetry/otlp-exporter-base';
+import { f as OTLPExporterConfig, g as EdgeConfig, R as ResolvedEdgeConfig, C as ConfigurationOption, h as Trigger } from './types-Dj85cPUj.js';
+export { n as EdgeSubscriber, i as ExporterConfig, H as HandlerInstrumentation, m as InitialSpanInfo, I as InstrumentationOptions, L as LocalTrace, P as PostProcessorFn, k as ResolveConfigFn, j as SamplingConfig, S as ServiceConfig, T as TailSampleFn, l as TraceFlushableSpanProcessor } from './types-Dj85cPUj.js';
+export { Buffer } from 'node:buffer';
+
+/**
+ * Lightweight Span implementation for edge environments
+ */
+
+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;
+}
+/**
+ * Lightweight Span implementation for edge runtimes
+ */
+declare class SpanImpl implements Span, ReadableSpan {
+    name: string;
+    private readonly _spanContext;
+    private readonly onEnd;
+    readonly parentSpanId?: string;
+    readonly parentSpanContext?: SpanContext | undefined;
+    readonly kind: SpanKind;
+    readonly attributes: Attributes;
+    status: SpanStatus;
+    endTime: HrTime;
+    private _duration;
+    readonly startTime: HrTime;
+    readonly events: TimedEvent[];
+    readonly links: Link[];
+    readonly resource: Resource;
+    instrumentationScope: InstrumentationScope;
+    private _ended;
+    private _droppedAttributesCount;
+    private _droppedEventsCount;
+    private _droppedLinksCount;
+    constructor(init: SpanInit);
+    addLink(link: Link): this;
+    addLinks(links: Link[]): this;
+    spanContext(): SpanContext;
+    setAttribute(key: string, value?: AttributeValue): this;
+    setAttributes(attributes: Attributes): this;
+    addEvent(name: string, attributesOrStartTime?: Attributes | TimeInput, startTime?: TimeInput): this;
+    setStatus(status: SpanStatus): this;
+    updateName(name: string): this;
+    end(endTime?: TimeInput): void;
+    isRecording(): boolean;
+    recordException(exception: Exception, time?: TimeInput): void;
+    get duration(): HrTime;
+    get ended(): boolean;
+    get droppedAttributesCount(): number;
+    get droppedEventsCount(): number;
+    get droppedLinksCount(): number;
+}
+
+/**
+ * Lightweight WorkerTracer for edge environments
+ */
+
+/**
+ * WorkerTracer - Lightweight tracer for edge environments
+ */
+declare class WorkerTracer implements Tracer {
+    private readonly spanProcessors;
+    private readonly resource;
+    private headSampler;
+    constructor(spanProcessors: SpanProcessor[], resource: Resource);
+    /**
+     * Set the head sampler (called from config)
+     */
+    setHeadSampler(sampler: any): void;
+    /**
+     * Force flush spans for a specific trace
+     */
+    forceFlush(traceId?: string): Promise<void>;
+    /**
+     * Add extra resource attributes
+     */
+    addToResource(extra: Resource): void;
+    /**
+     * Start a new span
+     */
+    startSpan(name: string, options?: SpanOptions$1, context?: Context): Span;
+    /**
+     * Start an active span (with automatic context management)
+     */
+    startActiveSpan<F extends (span: Span) => ReturnType<F>>(name: string, fn: F): ReturnType<F>;
+    startActiveSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SpanOptions$1, fn: F): ReturnType<F>;
+    startActiveSpan<F extends (span: Span) => ReturnType<F>>(name: string, options: SpanOptions$1, context: Context, fn: F): ReturnType<F>;
+}
+/**
+ * Set attributes for the next span created
+ */
+declare function withNextSpan(attrs: Attributes): void;
+
+/**
+ * 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.
+ */
+
+/**
+ * Minimal OTLP exporter using fetch()
+ */
+declare class OTLPExporter implements SpanExporter {
+    private headers;
+    private url;
+    constructor(config: OTLPExporterConfig);
+    export(items: any[], resultCallback: (result: ExportResult) => void): void;
+    private _export;
+    send(items: any[], onSuccess: () => void, onError: (error: OTLPExporterError) => void): void;
+    shutdown(): Promise<void>;
+}
+
+/**
+ * AsyncLocalStorage-based context manager for edge environments
+ *
+ * Copyright The OpenTelemetry Authors
+ * Licensed under the Apache License, Version 2.0
+ */
+
+declare 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;
+    private _bindFunction;
+    /**
+     * By default, EventEmitter calls callbacks with their context, which we do
+     * not want. Instead we bind a specific context to all callbacks.
+     */
+    private _bindEventEmitter;
+    private _patchRemoveListener;
+    private _patchRemoveAllListeners;
+    private _patchAddListener;
+    private _createPatchMap;
+    private _getPatchMap;
+    private readonly _kOtListeners;
+    private _wrapped;
+}
+/**
+ * AsyncLocalStorage-based context manager for edge runtimes
+ */
+declare class AsyncLocalStorageContextManager extends AbstractAsyncHooksContextManager {
+    private _asyncLocalStorage;
+    constructor();
+    active(): Context;
+    with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(context: Context, fn: F, thisArg?: ThisParameterType<F>, ...args: A): ReturnType<F>;
+    enable(): this;
+    disable(): this;
+}
+
+/**
+ * Tracer provider for edge environments
+ */
+
+/**
+ * WorkerTracerProvider - Registers tracer globally
+ */
+declare class WorkerTracerProvider {
+    private tracer;
+    private contextManager;
+    constructor(spanProcessors: SpanProcessor[], resource: Resource);
+    /**
+     * Get the tracer instance
+     */
+    getTracer(_name: string, _version?: string, _config?: TracerConfig): WorkerTracer;
+    /**
+     * Register this provider as the global tracer
+     */
+    register(): void;
+}
+
+/**
+ * Configuration system for autotel-edge
+ */
+
+/**
+ * Type for config initialization function
+ */
+type Initialiser = (env: any, trigger: Trigger) => ResolvedEdgeConfig;
+/**
+ * Get the currently active config from context
+ *
+ * This reads the config from the active context, ensuring each request
+ * has its own isolated config even when multiple requests are in-flight.
+ */
+declare function getActiveConfig(): ResolvedEdgeConfig | null;
+/**
+ * Set the active config in context
+ *
+ * Returns a new context with the config stored. This context should be
+ * used with api_context.with() to ensure the config is isolated per-request.
+ *
+ * @example
+ * ```typescript
+ * const config = parseConfig({ service: { name: 'my-service' } });
+ * const context = setConfig(config);
+ *
+ * api_context.with(context, () => {
+ *   // Config is available here via getActiveConfig()
+ * });
+ * ```
+ */
+declare function setConfig(config: ResolvedEdgeConfig): Context;
+/**
+ * Parse and validate configuration
+ */
+declare function parseConfig(config: EdgeConfig): ResolvedEdgeConfig;
+/**
+ * Create a config initializer function
+ */
+declare function createInitialiser(config: ConfigurationOption): Initialiser;
+
+/**
+ * Trace context types and utilities
+ */
+
+/**
+ * Base trace context containing trace identifiers
+ */
+interface TraceContextBase {
+    traceId: string;
+    spanId: string;
+    correlationId: string;
+    'code.function'?: string;
+}
+/**
+ * Span methods available on trace context
+ */
+interface SpanMethods {
+    setAttribute(key: string, value: string | number | boolean): void;
+    setAttributes(attrs: Record<string, string | number | boolean>): void;
+    setStatus(status: {
+        code: SpanStatusCode;
+        message?: string;
+    }): void;
+    recordException(exception: Error): void;
+}
+/**
+ * Complete trace context that merges base context and span methods
+ *
+ * This is the ctx parameter passed to factory functions in trace().
+ * It provides access to trace IDs and span manipulation methods.
+ */
+type TraceContext = TraceContextBase & SpanMethods;
+
+/**
+ * Functional API for autotel-edge
+ *
+ * Provides zero-boilerplate tracing helpers that mirror the Node.js runtime
+ * implementation while staying optimized for edge environments.
+ */
+
+type ExtractFunctionSignature<T> = T extends (ctx: TraceContext) => infer F ? F extends (...args: infer Args) => infer Return ? (...args: Args) => Return : never : never;
+type WrappedFunction<TArgs extends any[], TReturn> = (...args: TArgs) => TReturn | Promise<TReturn>;
+/**
+ * trace function options
+ */
+interface traceOptions<TArgs extends any[] = any[], TReturn = any> {
+    name?: string;
+    serviceName?: string;
+    sampler?: Sampler;
+    attributesFromArgs?: (args: TArgs) => Record<string, unknown>;
+    attributesFromResult?: (result: TReturn) => Record<string, unknown>;
+    attributes?: Record<string, unknown>;
+}
+declare function trace<TReturn = any>(fn: () => TReturn): () => TReturn;
+declare function trace<TArgs extends any[], TReturn = any>(fn: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
+declare function trace<TReturn = any>(fnFactory: (ctx: TraceContext) => () => TReturn): () => TReturn;
+declare function trace<TReturn = any>(fn: (ctx: TraceContext) => TReturn): TReturn;
+declare function trace<TFactory extends (ctx: TraceContext) => (...args: any[]) => any>(fnFactory: TFactory): ExtractFunctionSignature<TFactory>;
+declare function trace<TArgs extends any[], TReturn = any>(fnFactory: (ctx: TraceContext) => (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
+declare function trace<TArgs extends any[] = any[], TReturn = any>(name: string, fn: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
+declare function trace<TReturn = any>(name: string, fn: (ctx: TraceContext) => TReturn): TReturn;
+declare function trace<TArgs extends any[] = any[], TReturn = any>(name: string, fnFactory: (ctx: TraceContext) => (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
+declare function trace<TArgs extends any[] = any[], TReturn = any>(options: traceOptions<TArgs, TReturn>, fn: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
+declare function trace<TReturn = any>(options: traceOptions<[], TReturn>, fn: (ctx: TraceContext) => TReturn): TReturn;
+declare function trace<TArgs extends any[] = any[], TReturn = any>(options: traceOptions<TArgs, TReturn>, fnFactory: (ctx: TraceContext) => (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
+declare function trace<TReturn = any>(fn: () => Promise<TReturn>): () => Promise<TReturn>;
+declare function trace<TArgs extends any[] = any[], TReturn = any>(fn: (...args: TArgs) => Promise<TReturn>): (...args: TArgs) => Promise<TReturn>;
+declare function trace<TReturn = any>(fn: (ctx: TraceContext) => Promise<TReturn>): Promise<TReturn>;
+declare function trace<TReturn = any>(fnFactory: (ctx: TraceContext) => () => Promise<TReturn>): () => Promise<TReturn>;
+declare function trace<TArgs extends any[] = any[], TReturn = any>(fnFactory: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>): (...args: TArgs) => Promise<TReturn>;
+declare function trace<TArgs extends any[] = any[], TReturn = any>(name: string, fn: (...args: TArgs) => Promise<TReturn>): (...args: TArgs) => Promise<TReturn>;
+declare function trace<TReturn = any>(name: string, fn: (ctx: TraceContext) => Promise<TReturn>): Promise<TReturn>;
+declare function trace<TArgs extends any[] = any[], TReturn = any>(name: string, fnFactory: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>): (...args: TArgs) => Promise<TReturn>;
+declare function trace<TArgs extends any[] = any[], TReturn = any>(options: traceOptions<TArgs, TReturn>, fn: (...args: TArgs) => Promise<TReturn>): (...args: TArgs) => Promise<TReturn>;
+declare function trace<TReturn = any>(options: traceOptions<[], TReturn>, fn: (ctx: TraceContext) => Promise<TReturn>): Promise<TReturn>;
+declare function trace<TArgs extends any[] = any[], TReturn = any>(options: traceOptions<TArgs, TReturn>, fnFactory: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>): (...args: TArgs) => Promise<TReturn>;
+declare function withTracing<TArgs extends any[] = any[], TReturn = any>(options: Omit<traceOptions<TArgs, TReturn>, 'name'>): (fnOrFactory: ((...args: TArgs) => TReturn | Promise<TReturn>) | ((ctx: TraceContext) => (...args: TArgs) => TReturn | Promise<TReturn>)) => WrappedFunction<TArgs, TReturn>;
+interface InstrumentOptions extends traceOptions {
+    functions: Record<string, any>;
+    overrides?: Record<string, Partial<traceOptions>>;
+    skip?: (string | RegExp | ((key: string, fn: Function) => boolean))[];
+}
+declare function instrument<T extends Record<string, any>>(options: InstrumentOptions): T;
+interface SpanOptions {
+    name: string;
+    attributes?: Record<string, string | number | boolean>;
+}
+declare function span<T = unknown>(options: SpanOptions, fn: (span: Span) => T): T;
+declare function span<T = unknown>(options: SpanOptions, fn: (span: Span) => Promise<T>): Promise<T>;
+
+export { AsyncLocalStorageContextManager, ConfigurationOption, EdgeConfig, type Initialiser, type InstrumentOptions, OTLPExporter, OTLPExporterConfig, ResolvedEdgeConfig, SpanImpl, type TraceContext, Trigger, WorkerTracer, WorkerTracerProvider, createInitialiser, getActiveConfig, instrument as instrumentFunctions, parseConfig, setConfig, span, trace, type traceOptions, withNextSpan, withTracing };