/**
 * Distributed Tracing System
 *
 * Implements distributed tracing for tracking requests across services
 */
export interface Span {
    traceId: string;
    spanId: string;
    parentSpanId?: string;
    name: string;
    startTime: number;
    endTime?: number;
    duration?: number;
    tags: Record<string, string | number | boolean>;
    logs: Array<{
        timestamp: number;
        message: string;
        fields?: Record<string, unknown>;
    }>;
    status: 'ok' | 'error';
    error?: {
        name: string;
        message: string;
        stack?: string;
    };
}
export interface Trace {
    traceId: string;
    spans: Span[];
    startTime: number;
    endTime?: number;
    duration?: number;
    rootSpan?: Span;
}
export declare class TracingSystem {
    private activeSpans;
    private completedTraces;
    private maxTraces;
    /**
     * Start a new trace
     */
    startTrace(name: string, tags?: Record<string, string | number | boolean>): Span;
    /**
     * Start a child span
     */
    startSpan(name: string, parentSpan: Span, tags?: Record<string, string | number | boolean>): Span;
    /**
     * End a span
     */
    endSpan(span: Span, error?: Error): void;
    /**
     * Add tag to span
     */
    setTag(span: Span, key: string, value: string | number | boolean): void;
    /**
     * Log event in span
     */
    log(span: Span, message: string, fields?: Record<string, unknown>): void;
    /**
     * Add span to trace
     */
    private addToTrace;
    /**
     * Get trace by ID
     */
    getTrace(traceId: string): Trace | undefined;
    /**
     * Get all traces
     */
    getAllTraces(): Trace[];
    /**
     * Clear all traces
     */
    clearTraces(): void;
    /**
     * Generate unique ID
     */
    private generateId;
    /**
     * Export traces in Jaeger format
     */
    exportJaeger(): unknown[];
}
/**
 * Default tracing system
 */
export declare const tracing: TracingSystem;
/**
 * Trace a function
 */
export declare function trace<T>(name: string, fn: (span: Span) => Promise<T>, parentSpan?: Span): Promise<T>;
/**
 * Trace synchronous function
 */
export declare function traceSync<T>(name: string, fn: (span: Span) => T, parentSpan?: Span): T;
/**
 * Extract trace context from headers
 */
export declare function extractTraceContext(headers: Headers | Record<string, string>): {
    traceId?: string;
    spanId?: string;
};
/**
 * Inject trace context into headers
 */
export declare function injectTraceContext(span: Span, headers: Headers | Record<string, string>): void;
/**
 * Create tracing middleware
 */
export declare function createTracingMiddleware<TRequest = unknown, TResponse = unknown>(): (request: TRequest & {
    headers?: Record<string, string>;
    url: string;
    method: string;
}, next: () => Promise<TResponse & {
    status?: number;
    headers?: Record<string, string>;
}>) => Promise<TResponse & {
    status?: number;
    headers?: Record<string, string>;
}>;
/**
 * Trace database query
 */
export declare function traceDBQuery<T>(query: string, fn: () => Promise<T>, parentSpan?: Span): Promise<T>;
/**
 * Trace API call
 */
export declare function traceAPICall<T>(method: string, url: string, fn: () => Promise<T>, parentSpan?: Span): Promise<T>;
/**
 * Trace cache operation
 */
export declare function traceCacheOperation<T>(operation: string, key: string, fn: () => Promise<T>, parentSpan?: Span): Promise<T>;
/**
 * Get span context for propagation
 */
export declare function getSpanContext(span: Span): {
    traceId: string;
    spanId: string;
    parentSpanId?: string;
};
/**
 * Create span from context
 */
export declare function createSpanFromContext(name: string, context: {
    traceId: string;
    spanId: string;
    parentSpanId?: string;
}, tags?: Record<string, string | number | boolean>): Span;
//# sourceMappingURL=tracing.d.ts.map