@xynehq/jaf/dist/core/tracing.d.ts

Juspay Agent Framework - A purely functional agent framework with immutable state and composable tools

import { TraceEvent, TraceId } from './types.js';
/**
 * Custom sanitizer function type
 * @param key - The field key
 * @param value - The field value
 * @param depth - Current depth in the object tree
 * @returns The sanitized value, or undefined to use default behavior
 */
export type CustomSanitizerFn = (key: string, value: any, depth: number) => any | undefined;
/**
 * Configuration for data sanitization
 */
export interface SanitizationConfig {
    /** Sanitization mode: 'blacklist' (default) or 'whitelist' */
    mode?: 'blacklist' | 'whitelist';
    /** Fields to allow when mode='whitelist' (only these fields will be visible) */
    allowedFields?: string[];
    /** Additional sensitive field patterns to redact (for blacklist mode) */
    sensitiveFields?: string[];
    /** Custom sanitizer function for fine-grained control */
    customSanitizer?: CustomSanitizerFn;
    /** Maximum depth for recursive sanitization (default: 5) */
    maxDepth?: number;
    /** Redaction placeholder (default: '[REDACTED]') */
    redactionPlaceholder?: string;
}
/**
 * Configure global sanitization settings for all trace collectors
 * @param config - Sanitization configuration
 *
 * @example
 * ```typescript
 * // Add custom sensitive fields
 * configureSanitization({
 *   sensitiveFields: ['customerId', 'bankAccount', 'ssn']
 * });
 *
 * // Use custom sanitizer function
 * configureSanitization({
 *   customSanitizer: (key, value, depth) => {
 *     // Custom logic for email masking
 *     if (key === 'email' && typeof value === 'string') {
 *       const [local, domain] = value.split('@');
 *       return `${local.substring(0, 2)}***@${domain}`;
 *     }
 *     // Return undefined to use default sanitization logic
 *     return undefined;
 *   }
 * });
 * ```
 */
export declare function configureSanitization(config: SanitizationConfig): void;
/**
 * Reset sanitization configuration to defaults
 */
export declare function resetSanitizationConfig(): void;
/**
 * Sanitize an object by redacting sensitive fields
 * @param obj - Object to sanitize
 * @param depth - Current recursion depth
 * @param config - Optional sanitization config (uses global config if not provided)
 */
export declare function sanitizeObject(obj: any, depth?: number, config?: SanitizationConfig, currentPath?: string): any;
export interface TraceCollector {
    collect(event: TraceEvent): void;
    getTrace(traceId: TraceId): TraceEvent[];
    getAllTraces(): Map<TraceId, TraceEvent[]>;
    clear(traceId?: TraceId): void;
}
export declare class InMemoryTraceCollector implements TraceCollector {
    private traces;
    collect(event: TraceEvent): void;
    getTrace(traceId: TraceId): TraceEvent[];
    getAllTraces(): Map<TraceId, TraceEvent[]>;
    clear(traceId?: TraceId): void;
}
export declare class ConsoleTraceCollector implements TraceCollector {
    private inMemory;
    collect(event: TraceEvent): void;
    getTrace(traceId: TraceId): TraceEvent[];
    getAllTraces(): Map<TraceId, TraceEvent[]>;
    clear(traceId?: TraceId): void;
}
export declare class FileTraceCollector implements TraceCollector {
    private filePath;
    private inMemory;
    constructor(filePath: string);
    collect(event: TraceEvent): void;
    getTrace(traceId: TraceId): TraceEvent[];
    getAllTraces(): Map<TraceId, TraceEvent[]>;
    clear(traceId?: TraceId): void;
}
/**
 * Configure proxy settings manually for OpenTelemetry trace exports
 *
 * This function allows you to programmatically set a proxy URL that will be used
 * for all OpenTelemetry trace exports. It takes priority over environment variables.
 *
 * @param proxyUrl - The proxy URL (e.g., 'http://proxy.example.com:8080')
 *
 * @example
 * ```typescript
 * import { configureProxy, OpenTelemetryTraceCollector } from '@xynehq/jaf';
 *
 * // Configure proxy before creating trace collector
 * configureProxy('http://proxy.example.com:8080');
 *
 * // With authentication
 * configureProxy('http://username:password@proxy.example.com:8080');
 *
 * // Then create your trace collector
 * const collector = new OpenTelemetryTraceCollector();
 * ```
 */
export declare function configureProxy(proxyUrl: string): void;
/**
 * Reset manual proxy configuration
 *
 * This clears any manually configured proxy settings. After calling this,
 * JAF will fall back to environment variables for proxy configuration.
 *
 * @example
 * ```typescript
 * import { resetProxyConfig } from '@xynehq/jaf';
 *
 * resetProxyConfig();  // Clear manual proxy config
 * ```
 */
export declare function resetProxyConfig(): void;
export declare class OpenTelemetryTraceCollector implements TraceCollector {
    private inMemory;
    private activeSpans;
    private traceSpans;
    private tokenUsage;
    private traceModels;
    private tracer;
    constructor(serviceName?: string);
    collect(event: TraceEvent): void;
    private _getTraceId;
    private _getSpanId;
    getTrace(traceId: TraceId): TraceEvent[];
    getAllTraces(): Map<TraceId, TraceEvent[]>;
    clear(traceId?: TraceId): void;
}
export declare function createCompositeTraceCollector(...collectors: TraceCollector[]): TraceCollector;
//# sourceMappingURL=tracing.d.ts.map