@inference-net/otel-cf-workers 2.0.0

package/dist/index.d.ts

@@ -0,0 +1,555 @@
+import { Attributes } from '@opentelemetry/api';
+import { AttributeValue } from '@opentelemetry/api';
+import { Context } from '@opentelemetry/api';
+import { DurableObject as DurableObject_2 } from 'cloudflare:workers';
+import { Exception } from '@opentelemetry/api';
+import { ExportResult } from '@opentelemetry/core';
+import { HrTime } from '@opentelemetry/api';
+import { InstrumentationScope } from '@opentelemetry/core';
+import { Link } from '@opentelemetry/api';
+import { OTLPExporterError } from '@opentelemetry/otlp-exporter-base';
+import { ReadableSpan } from '@opentelemetry/sdk-trace-base';
+import { Resource } from '@opentelemetry/resources';
+import { Sampler } from '@opentelemetry/sdk-trace-base';
+import { Span } from '@opentelemetry/api';
+import { SpanContext } from '@opentelemetry/api';
+import { SpanExporter } from '@opentelemetry/sdk-trace-base';
+import { SpanKind } from '@opentelemetry/api';
+import { SpanOptions } from '@opentelemetry/api';
+import { SpanProcessor } from '@opentelemetry/sdk-trace-base';
+import { SpanStatus } from '@opentelemetry/api';
+import { TextMapPropagator } from '@opentelemetry/api';
+import { TimedEvent } from '@opentelemetry/sdk-trace-base';
+import { TimeInput } from '@opentelemetry/api';
+
+export declare const __unwrappedFetch: typeof fetch;
+
+declare type AcceptTraceContextFn = (request: Request) => boolean;
+
+export declare interface BatchConfig {
+    strategy?: 'immediate' | 'size';
+    maxQueueSize?: number;
+    maxExportBatchSize?: number;
+}
+
+/**
+ * Batch Size Log Record Processor
+ * Batches log records up to a maximum queue size before exporting
+ */
+export declare class BatchSizeLogRecordProcessor implements LogRecordProcessor {
+    private transport;
+    private logRecords;
+    private exportPromises;
+    private maxQueueSize;
+    private maxExportBatchSize;
+    constructor(transport: LogTransport, config?: BatchConfig);
+    onEmit(logRecord: ReadableLogRecord, _context: Context): void;
+    forceFlush(): Promise<void>;
+    private export;
+    shutdown(): Promise<void>;
+}
+
+export declare type BatchStrategy = 'trace' | 'immediate' | 'size';
+
+export declare class BatchTraceSpanProcessor implements TraceFlushableSpanProcessor {
+    private exporter;
+    private traces;
+    constructor(exporter: SpanExporter);
+    getTraceState(traceId: string): TraceState;
+    onStart(span: Span, _parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    forceFlush(traceId?: traceId): Promise<void>;
+    shutdown(): Promise<void>;
+}
+
+export declare type ConfigurationOption = WorkerOtelConfig | ResolveConfigFn;
+
+/**
+ * Console Transport for Logs
+ * Pretty-prints logs to the console for development
+ */
+export declare class ConsoleTransport implements LogTransport {
+    readonly name = "console";
+    private options;
+    constructor(options?: ConsoleTransportConfig);
+    export(logs: ReadableLogRecord[], callback: ExportResultCallback): void;
+    private printLog;
+    private prettyPrint;
+    private serializeLog;
+    private getSeverityText;
+    shutdown(): Promise<void>;
+}
+
+export declare interface ConsoleTransportConfig {
+    pretty?: boolean;
+    colors?: boolean;
+    includeTimestamp?: boolean;
+}
+
+/**
+ * Factory function to create a log processor based on strategy
+ */
+export declare function createLogProcessor(transport: LogTransport, config?: BatchConfig): LogRecordProcessor;
+
+export declare function createSampler(conf: ParentRatioSamplingConfig): Sampler;
+
+declare type DO = DurableObject | DurableObject_2;
+
+declare type DOClass = {
+    new (state: DurableObjectState, env: any): DO;
+};
+
+export declare interface DOConstructorTrigger {
+    id: string;
+    name?: string;
+}
+
+declare type Env_2 = Record<string, any>;
+
+export declare type ExporterConfig = OTLPExporterConfig | SpanExporter;
+
+export declare type ExportResultCallback = (result: ExportResult) => void;
+
+export declare const exportSpans: typeof exportTelemetry;
+
+export declare function exportTelemetry(traceId: string, tracker?: PromiseTracker): Promise<void>;
+
+declare interface FetcherConfig {
+    includeTraceContext?: boolean | IncludeTraceContextFn;
+}
+
+declare interface FetchHandlerConfig {
+    /**
+     * Whether to enable context propagation for incoming requests to `fetch`.
+     * This enables or disables distributed tracing from W3C Trace Context headers.
+     * @default true
+     */
+    acceptTraceContext?: boolean | AcceptTraceContextFn;
+}
+
+export declare function getGlobalLoggerProvider(): LoggerProvider;
+
+export declare function getLogger(name: string, version?: string, options?: LoggerOptions): Logger;
+
+export declare interface HandlerConfig {
+    fetch?: FetchHandlerConfig;
+}
+
+export declare interface HandlerInstrumentation<T extends Trigger, R extends any> {
+    getInitialSpanInfo: (trigger: T) => InitialSpanInfo;
+    getAttributesFromResult?: (result: Awaited<R>) => Attributes;
+    instrumentTrigger?: (trigger: T) => T;
+    executionSucces?: (span: Span, trigger: T, result: Awaited<R>) => void;
+    executionFailed?: (span: Span, trigger: T, error?: any) => void;
+}
+
+declare type HeadSamplerConf = Sampler | ParentRatioSamplingConfig;
+
+/**
+ * Immediate Log Record Processor
+ * Exports each log record immediately without batching
+ */
+export declare class ImmediateLogRecordProcessor implements LogRecordProcessor {
+    private transport;
+    private exportPromises;
+    constructor(transport: LogTransport);
+    onEmit(logRecord: ReadableLogRecord, _context: Context): void;
+    private exportLog;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+
+declare type IncludeTraceContextFn = (request: Request) => boolean;
+
+export declare interface InitialSpanInfo {
+    name: string;
+    options: SpanOptions;
+    context?: Context;
+}
+
+export declare function instrument<E extends Env_2, Q, C>(handler: ExportedHandler<E, Q, C>, config: ConfigurationOption): ExportedHandler<E, Q, C>;
+
+export declare interface InstrumentationOptions {
+    instrumentGlobalFetch?: boolean;
+    instrumentGlobalCache?: boolean;
+}
+
+export declare function instrumentDO(doClass: DOClass, config: ConfigurationOption): DOClass;
+
+export declare function isAlarm(trigger: Trigger): trigger is 'do-alarm';
+
+export declare const isHeadSampled: TailSampleFn;
+
+export declare function isMessageBatch(trigger: Trigger): trigger is MessageBatch;
+
+export declare function isRequest(trigger: Trigger): trigger is Request;
+
+export declare const isRootErrorSpan: TailSampleFn;
+
+export declare function isSpanProcessorConfig(config: TraceConfig): config is TraceConfigSpanProcessors;
+
+export declare interface LocalTrace {
+    readonly traceId: string;
+    readonly localRootSpan: ReadableSpan;
+    readonly spans: ReadableSpan[];
+}
+
+export declare interface LogAttributes {
+    [key: string]: any;
+}
+
+export declare type LogBody = string | Record<string, any>;
+
+export declare interface Logger {
+    emit(logRecord: Partial<LogRecord>): void;
+    trace(message: string, attributes?: LogAttributes): void;
+    debug(message: string, attributes?: LogAttributes): void;
+    info(message: string, attributes?: LogAttributes): void;
+    warn(message: string, attributes?: LogAttributes): void;
+    error(message: string | Error, attributes?: LogAttributes): void;
+    fatal(message: string, attributes?: LogAttributes): void;
+    forceFlush(): Promise<void>;
+    child(attributes: LogAttributes): Logger;
+}
+
+export declare interface LoggerOptions {
+    schemaUrl?: string;
+}
+
+export declare interface LoggerProvider {
+    getLogger(name: string, version?: string, options?: LoggerOptions): Logger;
+    register(): void;
+    shutdown(): Promise<void>;
+}
+
+export declare interface LogRecord {
+    readonly timeUnixNano: HrTime;
+    readonly observedTimeUnixNano: HrTime;
+    readonly severityNumber?: SeverityNumber;
+    readonly severityText?: string;
+    readonly body?: LogBody;
+    readonly attributes: LogAttributes;
+    readonly traceId?: string;
+    readonly spanId?: string;
+    readonly traceFlags?: number;
+}
+
+export declare interface LogRecordProcessor {
+    onEmit(logRecord: ReadableLogRecord, context: Context): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+
+export declare interface LogsConfig {
+    transports?: LogTransport[];
+    batching?: BatchConfig;
+    instrumentation?: LogsInstrumentationOptions;
+}
+
+export declare interface LogsInstrumentationOptions {
+    instrumentConsole?: boolean;
+}
+
+export declare interface LogTransport {
+    readonly name: string;
+    export(logs: ReadableLogRecord[], callback: ExportResultCallback): void;
+    shutdown(): Promise<void>;
+}
+
+export declare class MultiSpanExporter implements SpanExporter {
+    private exporters;
+    constructor(exporters: Array<SpanExporter>);
+    export(items: any[], resultCallback: (result: ExportResult) => void): void;
+    shutdown(): Promise<void>;
+}
+
+export declare class MultiSpanExporterAsync implements SpanExporter {
+    private exporters;
+    constructor(exporters: Array<SpanExporter>);
+    export(items: any[], resultCallback: (result: ExportResult) => void): void;
+    shutdown(): Promise<void>;
+}
+
+export declare function multiTailSampler(samplers: TailSampleFn[]): TailSampleFn;
+
+/**
+ * Multi-Transport Log Record Processor
+ * Sends log records to multiple transports in parallel
+ */
+export declare class MultiTransportLogRecordProcessor implements LogRecordProcessor {
+    private processors;
+    constructor(transports: LogTransport[], config?: BatchConfig);
+    onEmit(logRecord: ReadableLogRecord, context: Context): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+
+declare type OnSpanEnd = (span: Span) => void;
+
+export declare type OrPromise<T extends any> = T | Promise<T>;
+
+export 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>;
+}
+
+export declare interface OTLPExporterConfig {
+    url: string;
+    headers?: Record<string, string>;
+}
+
+/**
+ * OTLP HTTP/JSON Transport for Logs
+ * Sends logs to an OpenTelemetry-compatible backend using OTLP/HTTP protocol
+ */
+export declare class OTLPTransport implements LogTransport {
+    readonly name = "otlp";
+    private headers;
+    private url;
+    constructor(config: OTLPTransportConfig);
+    export(logs: ReadableLogRecord[], callback: ExportResultCallback): void;
+    private _export;
+    private send;
+    private transformToOTLP;
+    private transformLogRecord;
+    private transformBody;
+    private transformAttributes;
+    private transformAttributeValue;
+    private hrTimeToString;
+    shutdown(): Promise<void>;
+}
+
+export declare interface OTLPTransportConfig {
+    url: string;
+    headers?: Record<string, string>;
+}
+
+export declare interface ParentRatioSamplingConfig {
+    acceptRemote?: boolean;
+    ratio: number;
+}
+
+export declare type PostProcessorFn = (spans: ReadableSpan[]) => ReadableSpan[];
+
+declare class PromiseTracker {
+    _outstandingPromises: Promise<unknown>[];
+    get outstandingPromiseCount(): number;
+    track(promise: Promise<unknown>): void;
+    wait(): Promise<void>;
+}
+
+export declare interface ReadableLogRecord extends LogRecord {
+    readonly resource: Resource;
+    readonly instrumentationScope: InstrumentationScope;
+    readonly droppedAttributesCount: number;
+}
+
+export declare type ResolveConfigFn<Env = any> = (env: Env, trigger: Trigger) => WorkerOtelConfig;
+
+export declare interface ResolvedLogsConfig {
+    processors: LogRecordProcessor[];
+    instrumentation: LogsInstrumentationOptions;
+}
+
+export declare interface ResolvedTraceConfig extends TraceConfigBase {
+    handlers: Required<HandlerConfig>;
+    fetch: Required<FetcherConfig>;
+    postProcessor: PostProcessorFn;
+    sampling: Required<SamplingConfig<Sampler>>;
+    spanProcessors: SpanProcessor[];
+    instrumentation: InstrumentationOptions;
+    batching: TraceBatchConfig;
+}
+
+export declare interface SamplingConfig<HS extends HeadSamplerConf = HeadSamplerConf> {
+    headSampler?: HS;
+    tailSampler?: TailSampleFn;
+}
+
+export declare interface ServiceConfig {
+    name: string;
+    namespace?: string;
+    version?: string;
+}
+
+export declare function setGlobalLoggerProvider(provider: LoggerProvider): void;
+
+export declare const SEVERITY_NUMBERS: {
+    readonly TRACE: 1;
+    readonly TRACE2: 2;
+    readonly TRACE3: 3;
+    readonly TRACE4: 4;
+    readonly DEBUG: 5;
+    readonly DEBUG2: 6;
+    readonly DEBUG3: 7;
+    readonly DEBUG4: 8;
+    readonly INFO: 9;
+    readonly INFO2: 10;
+    readonly INFO3: 11;
+    readonly INFO4: 12;
+    readonly WARN: 13;
+    readonly WARN2: 14;
+    readonly WARN3: 15;
+    readonly WARN4: 16;
+    readonly ERROR: 17;
+    readonly ERROR2: 18;
+    readonly ERROR3: 19;
+    readonly ERROR4: 20;
+    readonly FATAL: 21;
+    readonly FATAL2: 22;
+    readonly FATAL3: 23;
+    readonly FATAL4: 24;
+};
+
+export declare type SeverityNumber = (typeof SEVERITY_NUMBERS)[keyof typeof SEVERITY_NUMBERS];
+
+export 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;
+}
+
+declare interface SpanInit {
+    attributes: unknown;
+    name: string;
+    onEnd: OnSpanEnd;
+    resource: Resource;
+    spanContext: SpanContext;
+    parentSpanContext?: SpanContext;
+    links?: Link[];
+    parentSpanId?: string;
+    spanKind?: SpanKind;
+    startTime?: TimeInput;
+}
+
+export declare type TailSampleFn = (traceInfo: LocalTrace) => boolean;
+
+export declare interface TraceBatchConfig {
+    strategy?: BatchStrategy;
+    maxQueueSize?: number;
+    maxExportBatchSize?: number;
+}
+
+export declare type TraceConfig = TraceConfigExporter | TraceConfigSpanProcessors;
+
+declare interface TraceConfigBase {
+    handlers?: HandlerConfig;
+    fetch?: FetcherConfig;
+    postProcessor?: PostProcessorFn;
+    sampling?: SamplingConfig;
+    instrumentation?: InstrumentationOptions;
+    batching?: TraceBatchConfig;
+}
+
+declare interface TraceConfigExporter extends TraceConfigBase {
+    exporter: ExporterConfig;
+}
+
+declare interface TraceConfigSpanProcessors extends TraceConfigBase {
+    spanProcessors: SpanProcessor | SpanProcessor[];
+}
+
+export declare type TraceFlushableSpanProcessor = SpanProcessor & {
+    forceFlush: (traceId?: string) => Promise<void>;
+};
+
+declare type traceId = string;
+
+declare class TraceState {
+    private unexportedSpans;
+    private inprogressSpans;
+    private exporter;
+    private exportPromises;
+    private localRootSpan?;
+    private traceDecision?;
+    constructor(exporter: SpanExporter);
+    addSpan(span: Span): void;
+    endSpan(span: ReadableSpan): void;
+    sample(): void;
+    flush(): Promise<void>;
+    private isSpanInProgress;
+    private exportSpans;
+}
+
+export declare type Trigger = Request | MessageBatch | ScheduledController | DOConstructorTrigger | 'do-alarm' | ForwardableEmailMessage;
+
+export declare function withNextSpan(attrs: Attributes): void;
+
+export declare class WorkerLogger implements Logger {
+    private readonly processors;
+    private readonly resource;
+    private readonly name;
+    private readonly version?;
+    private readonly inheritedAttributes;
+    constructor(name: string, processors: LogRecordProcessor[], resource: Resource, version?: string, inheritedAttributes?: LogAttributes);
+    emit(logRecord: Partial<LogRecord>): void;
+    trace(message: string, attributes?: LogAttributes): void;
+    debug(message: string, attributes?: LogAttributes): void;
+    info(message: string, attributes?: LogAttributes): void;
+    warn(message: string, attributes?: LogAttributes): void;
+    error(message: string | Error, attributes?: LogAttributes): void;
+    fatal(message: string, attributes?: LogAttributes): void;
+    forceFlush(): Promise<void>;
+    /**
+     * Create a child logger that inherits attributes from this logger
+     * Child attributes are merged with parent attributes (child takes precedence)
+     */
+    child(attributes: LogAttributes): Logger;
+}
+
+export declare class WorkerLoggerProvider implements LoggerProvider {
+    private loggers;
+    private processors;
+    private resource;
+    constructor(processors: LogRecordProcessor[], resource: Resource);
+    getLogger(name: string, version?: string, options?: LoggerOptions): Logger;
+    register(): void;
+    shutdown(): Promise<void>;
+}
+
+export declare interface WorkerOtelConfig {
+    service: ServiceConfig;
+    trace?: TraceConfig;
+    logs?: LogsConfig;
+    propagator?: TextMapPropagator;
+}
+
+export { }