export type WebSocketTelemetryRecordBase = {
    timestamp: number;
    monotonicTime?: number;
    runtimeId: string;
    nodeId: string;
    namespace?: string;
    connectionId?: string;
    userId?: string;
    traceId?: string;
    spanId?: string;
    parentSpanId?: string;
    sampled?: boolean;
};
export type WebSocketTelemetryEventRecord = WebSocketTelemetryRecordBase & {
    type: "event";
    name: string;
    level: "debug" | "info" | "warn" | "error";
    attributes?: Record<string, string | number | boolean>;
    detail?: Record<string, unknown>;
    payloadPreview?: string;
};
export type WebSocketTelemetryMetricRecord = WebSocketTelemetryRecordBase & {
    type: "metric";
    name: string;
    kind: "counter" | "histogram" | "gauge";
    value: number;
    unit?: "1" | "ms" | "By";
    tags?: Record<string, string>;
    snapshot?: WebSocketTelemetryMetricsSnapshot;
};
export type WebSocketTelemetrySpanRecord = WebSocketTelemetryRecordBase & {
    type: "span";
    operationName: string;
    kind: "internal" | "producer" | "consumer" | "server" | "client";
    durationMs: number;
    status: "unset" | "ok" | "error";
    attributes?: Record<string, string | number | boolean>;
    errorType?: string;
    events?: Array<{
        name: string;
        timestamp: number;
        attributes?: Record<string, unknown>;
    }>;
    links?: Array<{
        traceId: string;
        spanId: string;
        attributes?: Record<string, unknown>;
    }>;
};
export type WebSocketTelemetryRecord = WebSocketTelemetryEventRecord | WebSocketTelemetryMetricRecord | WebSocketTelemetrySpanRecord;
export type WebSocketTelemetryEventInput = {
    name: string;
    level: "debug" | "info" | "warn" | "error";
    namespace?: string;
    connectionId?: string;
    userId?: string;
    attributes?: Record<string, string | number | boolean>;
    detail?: Record<string, unknown>;
    payload?: unknown;
    traceId?: string;
    spanId?: string;
    parentSpanId?: string;
    sampled?: boolean;
};
export type WebSocketMetricInput = {
    name: string;
    kind: "counter" | "histogram" | "gauge";
    value: number;
    unit?: "1" | "ms" | "By";
    tags?: Record<string, string>;
    namespace?: string;
    connectionId?: string;
    userId?: string;
    traceId?: string;
    spanId?: string;
    parentSpanId?: string;
    sampled?: boolean;
    snapshot?: WebSocketTelemetryMetricsSnapshot;
};
export type WebSocketSpanInput = {
    operationName: string;
    kind: "internal" | "producer" | "consumer" | "server" | "client";
    durationMs: number;
    status: "unset" | "ok" | "error";
    namespace?: string;
    connectionId?: string;
    userId?: string;
    attributes?: Record<string, string | number | boolean>;
    errorType?: string;
    traceId?: string;
    spanId?: string;
    parentSpanId?: string;
    sampled?: boolean;
    events?: Array<{
        name: string;
        timestamp: number;
        attributes?: Record<string, unknown>;
    }>;
    links?: Array<{
        traceId: string;
        spanId: string;
        attributes?: Record<string, unknown>;
    }>;
};
export type WebSocketTelemetryInput = ({
    type: "event";
} & WebSocketTelemetryEventInput) | ({
    type: "metric";
} & WebSocketMetricInput) | ({
    type: "span";
} & WebSocketSpanInput);
export type WebSocketTelemetryMetricsSnapshot = {
    timestamp: number;
    activeConnections: number;
    activeConnectionsByNamespace: Record<string, number>;
    roomCount: number;
    pendingInboundMessages: number;
    pendingOutboundMessages: number;
    socketBufferedBytes: number;
    pendingFanOutJobs: number;
    pendingFanOutTargets: number;
    telemetryDroppedRecords: number;
    telemetrySinkFailures: number;
};
export type WebSocketTelemetryConnectionSnapshot = {
    pendingInboundMessages: number;
    pendingOutboundMessages: number;
    socketBufferedBytes: number;
};
export interface TelemetryInspectableConnection {
    getTelemetrySnapshot(): WebSocketTelemetryConnectionSnapshot;
}
export interface WebSocketTelemetryEventSink {
    emit(record: WebSocketTelemetryEventRecord): void | Promise<void>;
    shutdown?(options?: {
        timeoutMs?: number;
    }): void | Promise<void>;
}
export interface WebSocketTelemetryMetricSink {
    emit(record: WebSocketTelemetryMetricRecord): void | Promise<void>;
    shutdown?(options?: {
        timeoutMs?: number;
    }): void | Promise<void>;
}
export interface WebSocketTelemetrySpanSink {
    emit(record: WebSocketTelemetrySpanRecord): void | Promise<void>;
    shutdown?(options?: {
        timeoutMs?: number;
    }): void | Promise<void>;
}
export type WebSocketTelemetryEventQueryFilter = {
    name?: string;
    level?: "debug" | "info" | "warn" | "error";
    connectionId?: string;
    userId?: string;
    namespace?: string;
    traceId?: string;
    since?: number;
    until?: number;
    limit?: number;
};
export type WebSocketTelemetryMetricQueryFilter = {
    name?: string;
    kind?: "counter" | "histogram" | "gauge";
    connectionId?: string;
    userId?: string;
    namespace?: string;
    traceId?: string;
    since?: number;
    until?: number;
    limit?: number;
};
export type WebSocketTelemetrySpanQueryFilter = {
    operationName?: string;
    kind?: "internal" | "producer" | "consumer" | "server" | "client";
    status?: "unset" | "ok" | "error";
    connectionId?: string;
    userId?: string;
    namespace?: string;
    traceId?: string;
    since?: number;
    until?: number;
    limit?: number;
};
export interface WebSocketTelemetryEventStore {
    readonly sink: WebSocketTelemetryEventSink;
    query(filter: WebSocketTelemetryEventQueryFilter): WebSocketTelemetryEventRecord[];
    clear(): void;
}
export interface WebSocketTelemetryMetricStore {
    readonly sink: WebSocketTelemetryMetricSink;
    query(filter: WebSocketTelemetryMetricQueryFilter): WebSocketTelemetryMetricRecord[];
    clear(): void;
}
export interface WebSocketTelemetrySpanStore {
    readonly sink: WebSocketTelemetrySpanSink;
    query(filter: WebSocketTelemetrySpanQueryFilter): WebSocketTelemetrySpanRecord[];
    clear(): void;
}
export interface WebSocketTelemetryMetricSource {
    collect(now: number): Partial<WebSocketTelemetryMetricsSnapshot>;
}
export type WebSocketTelemetryEventRedactor = (record: WebSocketTelemetryEventRecord) => WebSocketTelemetryEventRecord | null;
export type WebSocketTelemetryMetricRedactor = (record: WebSocketTelemetryMetricRecord) => WebSocketTelemetryMetricRecord | null;
export type WebSocketTelemetrySpanRedactor = (record: WebSocketTelemetrySpanRecord) => WebSocketTelemetrySpanRecord | null;
export type WebSocketTelemetryRedactor = (record: WebSocketTelemetryRecord) => WebSocketTelemetryRecord | null;
export type WebSocketTelemetryEventBeforeRecord = (record: WebSocketTelemetryEventRecord) => WebSocketTelemetryEventRecord | null;
export type WebSocketTelemetryMetricBeforeRecord = (record: WebSocketTelemetryMetricRecord) => WebSocketTelemetryMetricRecord | null;
export type WebSocketTelemetrySpanBeforeRecord = (record: WebSocketTelemetrySpanRecord) => WebSocketTelemetrySpanRecord | null;
export type WebSocketTelemetryBeforeRecord = (record: WebSocketTelemetryRecord) => WebSocketTelemetryRecord | null;
export type WebSocketTelemetryTraceOptions = {
    extractTraceParent: boolean;
    generateConnectionTrace: boolean;
    propagateMessageTrace: boolean;
    recordConnectionLifetimeSpan: boolean;
};
export type WebSocketTelemetryConnectionContext = {
    traceId?: string;
    spanId?: string;
    parentSpanId?: string;
    sampled?: boolean;
};
export interface TelemetryContextProvider {
    getTelemetryContext(): WebSocketTelemetryConnectionContext;
}
export type WebSocketTelemetryEventSamplingOptions = {
    defaultRate?: number;
    rateByEvent?: Record<string, number>;
    maxRecordsPerSecond?: number;
    alwaysRecordLevels?: Array<"warn" | "error">;
};
export type WebSocketTelemetryMetricSamplingOptions = {
    maxRecordsPerSecond?: number;
};
export type WebSocketTelemetrySpanSamplingOptions = {
    defaultRate?: number;
    maxRecordsPerSecond?: number;
};
export type WebSocketTelemetryDefaultsOptions = {
    redactor?: WebSocketTelemetryRedactor;
    beforeRecord?: WebSocketTelemetryBeforeRecord;
    maxRecords?: number;
    maxBytes?: number;
    maxRecordsPerSecond?: number;
};
export type WebSocketTelemetryEventsOptions = {
    sinks?: WebSocketTelemetryEventSink[];
    store?: WebSocketTelemetryEventStore;
    maxRecords?: number;
    maxBytes?: number;
    maxInFlightEmits?: number;
    redactor?: WebSocketTelemetryEventRedactor | null;
    beforeRecord?: WebSocketTelemetryEventBeforeRecord | null;
    sampling?: WebSocketTelemetryEventSamplingOptions;
    capturePayload?: false | "preview";
    maxPayloadPreviewBytes?: number;
};
export type WebSocketTelemetryMetricsOptions = {
    sinks?: WebSocketTelemetryMetricSink[];
    store?: WebSocketTelemetryMetricStore;
    maxRecords?: number;
    maxBytes?: number;
    maxInFlightEmits?: number;
    redactor?: WebSocketTelemetryMetricRedactor | null;
    beforeRecord?: WebSocketTelemetryMetricBeforeRecord | null;
    sampling?: WebSocketTelemetryMetricSamplingOptions;
    collectionEnabled?: boolean;
    sampleIntervalMs?: number;
};
export type WebSocketTelemetrySpansOptions = {
    sinks?: WebSocketTelemetrySpanSink[];
    store?: WebSocketTelemetrySpanStore;
    maxRecords?: number;
    maxBytes?: number;
    maxInFlightEmits?: number;
    redactor?: WebSocketTelemetrySpanRedactor | null;
    beforeRecord?: WebSocketTelemetrySpanBeforeRecord | null;
    sampling?: WebSocketTelemetrySpanSamplingOptions;
};
export type WebSocketTelemetryOptions = {
    enabled?: boolean;
    controller?: WebSocketTelemetryController;
    defaults?: WebSocketTelemetryDefaultsOptions;
    events?: WebSocketTelemetryEventsOptions;
    metrics?: WebSocketTelemetryMetricsOptions;
    spans?: WebSocketTelemetrySpansOptions;
    trace?: Partial<WebSocketTelemetryTraceOptions>;
    shutdownTimeoutMs?: number;
};
export interface WebSocketTelemetryController {
    emit(input: WebSocketTelemetryEventInput): void;
    recordMetric(input: WebSocketMetricInput): void;
    recordSpan(input: WebSocketSpanInput): void;
    getMetricsSnapshot(): WebSocketTelemetryMetricsSnapshot;
    getEventStore(): WebSocketTelemetryEventStore | undefined;
    getMetricStore(): WebSocketTelemetryMetricStore | undefined;
    getSpanStore(): WebSocketTelemetrySpanStore | undefined;
    registerMetricSource(source: WebSocketTelemetryMetricSource): () => void;
    createConnectionContext(request?: {
        headers?: Readonly<Record<string, string | string[] | undefined>>;
    }): WebSocketTelemetryConnectionContext;
    getTraceOptions(): WebSocketTelemetryTraceOptions;
    shutdown(options?: {
        timeoutMs?: number;
    }): Promise<void>;
}
export declare const EMPTY_METRICS_SNAPSHOT: WebSocketTelemetryMetricsSnapshot;
export declare const DEFAULT_TRACE_OPTIONS: WebSocketTelemetryTraceOptions;
export declare function isPromiseLike(value: unknown): value is Promise<void>;
declare class TokenBucket {
    private readonly maxTokens;
    private readonly refillRate;
    private tokens;
    private lastRefill;
    constructor(maxTokens: number, refillRate: number);
    tryConsume(): boolean;
    private refill;
}
export declare class NoopWebSocketTelemetryController implements WebSocketTelemetryController {
    emit(_input: WebSocketTelemetryEventInput): void;
    recordMetric(_input: WebSocketMetricInput): void;
    recordSpan(_input: WebSocketSpanInput): void;
    getMetricsSnapshot(): WebSocketTelemetryMetricsSnapshot;
    getEventStore(): WebSocketTelemetryEventStore | undefined;
    getMetricStore(): WebSocketTelemetryMetricStore | undefined;
    getSpanStore(): WebSocketTelemetrySpanStore | undefined;
    registerMetricSource(_source: WebSocketTelemetryMetricSource): () => void;
    createConnectionContext(_request?: {
        headers?: Readonly<Record<string, string | string[] | undefined>>;
    }): WebSocketTelemetryConnectionContext;
    getTraceOptions(): WebSocketTelemetryTraceOptions;
    shutdown(_options?: {
        timeoutMs?: number;
    }): Promise<void>;
}
type RuntimeMetadata = {
    runtimeId: string;
    nodeId: string;
};
type ResolvedEventPipelineOptions = {
    sinks: WebSocketTelemetryEventSink[];
    store: WebSocketTelemetryEventStore | undefined;
    maxRecordsPerSecond: number;
    maxInFlightEmits: number;
    sharedRedactor: WebSocketTelemetryRedactor | undefined;
    signalRedactor: WebSocketTelemetryEventRedactor | undefined;
    sharedBeforeRecord: WebSocketTelemetryBeforeRecord | undefined;
    signalBeforeRecord: WebSocketTelemetryEventBeforeRecord | undefined;
    sampling: {
        defaultRate: number;
        rateByEvent: Record<string, number>;
        alwaysRecordLevels: Array<"warn" | "error">;
    };
    capturePayload: false | "preview";
    maxPayloadPreviewBytes: number;
};
type ResolvedMetricPipelineOptions = {
    sinks: WebSocketTelemetryMetricSink[];
    store: WebSocketTelemetryMetricStore | undefined;
    maxRecordsPerSecond: number;
    maxInFlightEmits: number;
    sharedRedactor: WebSocketTelemetryRedactor | undefined;
    signalRedactor: WebSocketTelemetryMetricRedactor | undefined;
    sharedBeforeRecord: WebSocketTelemetryBeforeRecord | undefined;
    signalBeforeRecord: WebSocketTelemetryMetricBeforeRecord | undefined;
    collectionEnabled: boolean;
    sampleIntervalMs: number;
};
type ResolvedSpanPipelineOptions = {
    sinks: WebSocketTelemetrySpanSink[];
    store: WebSocketTelemetrySpanStore | undefined;
    maxRecordsPerSecond: number;
    maxInFlightEmits: number;
    sharedRedactor: WebSocketTelemetryRedactor | undefined;
    signalRedactor: WebSocketTelemetrySpanRedactor | undefined;
    sharedBeforeRecord: WebSocketTelemetryBeforeRecord | undefined;
    signalBeforeRecord: WebSocketTelemetrySpanBeforeRecord | undefined;
    sampling: {
        defaultRate: number;
    };
};
type InternalEventReporter = (name: string, level: WebSocketTelemetryEventRecord["level"], detail?: Record<string, unknown>) => void;
declare abstract class TelemetryPipeline<TRecord extends WebSocketTelemetryRecord, TInput, TSink extends {
    emit(record: TRecord): void | Promise<void>;
    shutdown?(options?: {
        timeoutMs?: number;
    }): void | Promise<void>;
}, TStore extends {
    readonly sink: TSink;
    clear(): void;
} | undefined> {
    abstract readonly signal: "event" | "metric" | "span";
    protected readonly sinks: TSink[];
    protected readonly _store: TStore;
    protected readonly tokenBucket: TokenBucket;
    protected readonly maxInFlightEmits: number;
    protected readonly runtimeMetadata: RuntimeMetadata;
    protected readonly sharedRedactor: WebSocketTelemetryRedactor | undefined;
    protected readonly sharedBeforeRecord: WebSocketTelemetryBeforeRecord | undefined;
    protected internalEventReporter: InternalEventReporter | undefined;
    private readonly inFlightEmits;
    droppedCount: number;
    sinkFailureCount: number;
    shutdownCalled: boolean;
    protected constructor(sinks: TSink[], store: TStore, maxRecordsPerSecond: number, maxInFlightEmits: number, sharedRedactor: WebSocketTelemetryRedactor | undefined, sharedBeforeRecord: WebSocketTelemetryBeforeRecord | undefined, runtimeMetadata: RuntimeMetadata);
    get store(): TStore;
    setInternalEventReporter(reporter: InternalEventReporter): void;
    abstract emit(input: TInput): void;
    protected abstract buildRecord(input: TInput): TRecord;
    protected abstract shouldBypassRateLimit(record: TRecord): boolean;
    protected abstract isCriticalRecord(record: TRecord): boolean;
    protected abstract getSignalRedactor(): ((record: TRecord) => TRecord | null) | undefined;
    protected abstract getSignalBeforeRecord(): ((record: TRecord) => TRecord | null) | undefined;
    protected emitInternal(input: TInput): void;
    private applyTransform;
    protected dispatchToSinks(record: TRecord, selfObserveFailures?: boolean): void;
    private decrementInFlightEmit;
    private observeSinkFailure;
    protected dispatchInternalEvent(name: string, level: WebSocketTelemetryEventRecord["level"], detail?: Record<string, unknown>): void;
    shutdown(timeoutMs: number): Promise<void>;
    private shutdownSink;
}
declare class EventPipeline extends TelemetryPipeline<WebSocketTelemetryEventRecord, WebSocketTelemetryEventInput, WebSocketTelemetryEventSink, WebSocketTelemetryEventStore | undefined> {
    readonly signal: "event";
    protected readonly signalRedactor: WebSocketTelemetryEventRedactor | undefined;
    protected readonly signalBeforeRecord: WebSocketTelemetryEventBeforeRecord | undefined;
    protected readonly sampling: {
        defaultRate: number;
        rateByEvent: Record<string, number>;
        alwaysRecordLevels: Array<"warn" | "error">;
    };
    protected readonly capturePayload: false | "preview";
    protected readonly maxPayloadPreviewBytes: number;
    private currentEmitAlwaysRecord;
    constructor(options: ResolvedEventPipelineOptions, runtimeMetadata: RuntimeMetadata);
    emit(input: WebSocketTelemetryEventInput): void;
    dispatchInternalDiagnosticEvent(name: string, level: WebSocketTelemetryEventRecord["level"], detail?: Record<string, unknown>): void;
    protected buildRecord(input: WebSocketTelemetryEventInput): WebSocketTelemetryEventRecord;
    protected shouldBypassRateLimit(_record: WebSocketTelemetryEventRecord): boolean;
    protected isCriticalRecord(record: WebSocketTelemetryEventRecord): boolean;
    protected getSignalRedactor(): ((record: WebSocketTelemetryEventRecord) => WebSocketTelemetryEventRecord | null) | undefined;
    protected getSignalBeforeRecord(): ((record: WebSocketTelemetryEventRecord) => WebSocketTelemetryEventRecord | null) | undefined;
}
declare class MetricPipeline extends TelemetryPipeline<WebSocketTelemetryMetricRecord, WebSocketMetricInput, WebSocketTelemetryMetricSink, WebSocketTelemetryMetricStore | undefined> {
    readonly signal: "metric";
    protected readonly signalRedactor: WebSocketTelemetryMetricRedactor | undefined;
    protected readonly signalBeforeRecord: WebSocketTelemetryMetricBeforeRecord | undefined;
    protected readonly metricSources: Set<WebSocketTelemetryMetricSource>;
    protected readonly collectionEnabled: boolean;
    protected readonly sampleIntervalMs: number;
    protected collectionInterval: ReturnType<typeof setInterval> | null;
    protected snapshotProvider: (() => WebSocketTelemetryMetricsSnapshot) | undefined;
    constructor(options: ResolvedMetricPipelineOptions, runtimeMetadata: RuntimeMetadata);
    emit(input: WebSocketMetricInput): void;
    protected buildRecord(input: WebSocketMetricInput): WebSocketTelemetryMetricRecord;
    protected shouldBypassRateLimit(record: WebSocketTelemetryMetricRecord): boolean;
    protected isCriticalRecord(record: WebSocketTelemetryMetricRecord): boolean;
    protected getSignalRedactor(): ((record: WebSocketTelemetryMetricRecord) => WebSocketTelemetryMetricRecord | null) | undefined;
    protected getSignalBeforeRecord(): ((record: WebSocketTelemetryMetricRecord) => WebSocketTelemetryMetricRecord | null) | undefined;
    registerMetricSource(source: WebSocketTelemetryMetricSource): () => void;
    setSnapshotProvider(provider: () => WebSocketTelemetryMetricsSnapshot): void;
    getSnapshot(): WebSocketTelemetryMetricsSnapshot;
    collectAndEmit(): void;
    shutdown(timeoutMs: number): Promise<void>;
}
declare class SpanPipeline extends TelemetryPipeline<WebSocketTelemetrySpanRecord, WebSocketSpanInput, WebSocketTelemetrySpanSink, WebSocketTelemetrySpanStore | undefined> {
    readonly signal: "span";
    protected readonly signalRedactor: WebSocketTelemetrySpanRedactor | undefined;
    protected readonly signalBeforeRecord: WebSocketTelemetrySpanBeforeRecord | undefined;
    protected readonly sampling: {
        defaultRate: number;
    };
    constructor(options: ResolvedSpanPipelineOptions, runtimeMetadata: RuntimeMetadata);
    emit(input: WebSocketSpanInput): void;
    protected buildRecord(input: WebSocketSpanInput): WebSocketTelemetrySpanRecord;
    protected shouldBypassRateLimit(record: WebSocketTelemetrySpanRecord): boolean;
    protected isCriticalRecord(record: WebSocketTelemetrySpanRecord): boolean;
    protected getSignalRedactor(): ((record: WebSocketTelemetrySpanRecord) => WebSocketTelemetrySpanRecord | null) | undefined;
    protected getSignalBeforeRecord(): ((record: WebSocketTelemetrySpanRecord) => WebSocketTelemetrySpanRecord | null) | undefined;
}
export declare class WebSocketTelemetryControllerImpl implements WebSocketTelemetryController {
    protected readonly events: EventPipeline;
    protected readonly metrics: MetricPipeline;
    protected readonly spans: SpanPipeline;
    protected readonly runtimeId: string;
    protected readonly nodeId: string;
    protected readonly traceOptions: WebSocketTelemetryTraceOptions;
    protected readonly shutdownTimeoutMs: number;
    protected shutdownCalled: boolean;
    constructor(events: EventPipeline, metrics: MetricPipeline, spans: SpanPipeline, traceOptions: WebSocketTelemetryTraceOptions, runtimeMetadata: RuntimeMetadata, shutdownTimeoutMs: number);
    emit(input: WebSocketTelemetryEventInput): void;
    recordMetric(input: WebSocketMetricInput): void;
    recordSpan(input: WebSocketSpanInput): void;
    getMetricsSnapshot(): WebSocketTelemetryMetricsSnapshot;
    getEventStore(): WebSocketTelemetryEventStore | undefined;
    getMetricStore(): WebSocketTelemetryMetricStore | undefined;
    getSpanStore(): WebSocketTelemetrySpanStore | undefined;
    registerMetricSource(source: WebSocketTelemetryMetricSource): () => void;
    createConnectionContext(request?: {
        headers?: Readonly<Record<string, string | string[] | undefined>>;
    }): WebSocketTelemetryConnectionContext;
    getTraceOptions(): WebSocketTelemetryTraceOptions;
    shutdown(options?: {
        timeoutMs?: number;
    }): Promise<void>;
}
export declare function createWebSocketTelemetryController(telemetryOption: boolean | WebSocketTelemetryOptions | undefined, runtimeMetadata: RuntimeMetadata): WebSocketTelemetryController;
export {};
//# sourceMappingURL=ws-telemetry.d.ts.map