@runtimescope/server-sdk 0.6.0

package/dist/index.d.ts

@@ -0,0 +1,186 @@
+type DatabaseOperation = 'SELECT' | 'INSERT' | 'UPDATE' | 'DELETE' | 'OTHER';
+type DatabaseSource = 'prisma' | 'drizzle' | 'knex' | 'pg' | 'mysql2' | 'better-sqlite3' | 'generic';
+interface DatabaseEvent {
+    eventId: string;
+    sessionId: string;
+    timestamp: number;
+    eventType: 'database';
+    query: string;
+    normalizedQuery: string;
+    duration: number;
+    rowsReturned?: number;
+    rowsAffected?: number;
+    tablesAccessed: string[];
+    operation: DatabaseOperation;
+    source: DatabaseSource;
+    stackTrace?: string;
+    label?: string;
+    error?: string;
+    params?: string;
+}
+type ConsoleLevel = 'log' | 'warn' | 'error' | 'info' | 'debug' | 'trace';
+interface ConsoleEvent {
+    eventId: string;
+    sessionId: string;
+    timestamp: number;
+    eventType: 'console';
+    level: ConsoleLevel;
+    message: string;
+    args: unknown[];
+    stackTrace?: string;
+    sourceFile?: string;
+}
+interface GraphQLOperation {
+    type: 'query' | 'mutation' | 'subscription';
+    name: string;
+}
+interface NetworkEvent {
+    eventId: string;
+    sessionId: string;
+    timestamp: number;
+    eventType: 'network';
+    url: string;
+    method: string;
+    status: number;
+    requestHeaders: Record<string, string>;
+    responseHeaders: Record<string, string>;
+    requestBodySize: number;
+    responseBodySize: number;
+    duration: number;
+    ttfb: number;
+    graphqlOperation?: GraphQLOperation;
+    requestBody?: string;
+    responseBody?: string;
+    errorPhase?: 'error' | 'abort' | 'timeout';
+    errorMessage?: string;
+    source?: 'fetch' | 'xhr' | 'node-http' | 'node-https';
+}
+type ServerMetricName = 'memory.rss' | 'memory.heapUsed' | 'memory.heapTotal' | 'memory.external' | 'eventloop.lag.mean' | 'eventloop.lag.p99' | 'eventloop.lag.max' | 'gc.pause.major' | 'gc.pause.minor' | 'cpu.user' | 'cpu.system' | 'handles.active' | 'requests.active';
+type MetricUnit = 'bytes' | 'ms' | 'percent' | 'count';
+interface PerformanceEvent {
+    eventId: string;
+    sessionId: string;
+    timestamp: number;
+    eventType: 'performance';
+    metricName: ServerMetricName;
+    value: number;
+    unit: MetricUnit;
+}
+type ServerRuntimeEvent = DatabaseEvent | ConsoleEvent | NetworkEvent | PerformanceEvent;
+interface ServerSdkConfig {
+    serverUrl?: string;
+    appName?: string;
+    sessionId?: string;
+    /** API key for authenticated connections to the collector */
+    authToken?: string;
+    captureStackTraces?: boolean;
+    redactParams?: boolean;
+    maxQueryLength?: number;
+    captureConsole?: boolean;
+    captureErrors?: boolean;
+    captureHttp?: boolean;
+    captureBody?: boolean;
+    maxBodySize?: number;
+    redactHeaders?: string[];
+    beforeSend?: (event: ServerRuntimeEvent) => ServerRuntimeEvent | null;
+    capturePerformance?: boolean;
+    performanceInterval?: number;
+    performanceMetrics?: ServerMetricName[];
+    sampleRate?: number;
+    maxEventsPerSecond?: number;
+    maxQueueSize?: number;
+}
+
+type EmitFn = (event: NetworkEvent) => void;
+interface MiddlewareOptions {
+    captureBody?: boolean;
+    maxBodySize?: number;
+    redactHeaders?: string[];
+    ignoreRoutes?: (string | RegExp)[];
+    beforeSend?: (event: ServerRuntimeEvent) => ServerRuntimeEvent | null;
+}
+/**
+ * Express/Connect-compatible middleware that captures incoming HTTP requests.
+ * Complements the HTTP interceptor (which captures outgoing requests).
+ *
+ * Usage:
+ *   app.use(RuntimeScope.middleware());
+ */
+declare function runtimeScopeMiddleware(emit: EmitFn, sessionId: string, options?: MiddlewareOptions): (req: any, res: any, next: any) => void;
+
+declare const _log: {
+    log: (...data: any[]) => void;
+    warn: (...data: any[]) => void;
+    error: (...data: any[]) => void;
+    debug: (...data: any[]) => void;
+};
+
+declare function generateId(): string;
+declare function generateSessionId(): string;
+
+declare function parseOperation(query: string): DatabaseOperation;
+declare function parseTablesAccessed(query: string): string[];
+declare function normalizeQuery(query: string): string;
+declare function redactParams(params: unknown[]): string;
+
+interface RequestContext {
+    sessionId: string;
+    requestId?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Run a function within a request context.
+ * All async operations within `fn` will inherit this context.
+ */
+declare function runWithContext<T>(ctx: RequestContext, fn: () => T): T;
+/**
+ * Get the current request context, if any.
+ */
+declare function getRequestContext(): RequestContext | undefined;
+/**
+ * Get the sessionId from the current request context,
+ * falling back to the global sessionId.
+ */
+declare function getSessionId(fallback: string): string;
+
+interface SamplerConfig {
+    /** Probabilistic sample rate: 0.0–1.0 (default: 1.0 = keep all) */
+    sampleRate?: number;
+    /** Max events per second before dropping (default: unlimited) */
+    maxEventsPerSecond?: number;
+}
+declare class Sampler {
+    private config;
+    private windowCount;
+    private windowStart;
+    private _droppedCount;
+    constructor(config: SamplerConfig);
+    get droppedCount(): number;
+    shouldSample(_event: ServerRuntimeEvent): boolean;
+    reset(): void;
+}
+
+declare class RuntimeScopeServer {
+    private transport;
+    private sessionId;
+    private config;
+    private sampler;
+    private restoreFunctions;
+    connect(config?: ServerSdkConfig): void;
+    disconnect(): void;
+    get currentSessionId(): string;
+    private emitEvent;
+    middleware(options?: MiddlewareOptions): (req: any, res: any, next: any) => void;
+    instrumentPrisma(client: unknown): typeof client;
+    instrumentPg(pool: unknown): typeof pool;
+    instrumentKnex(knex: unknown): typeof knex;
+    instrumentDrizzle(db: unknown): typeof db;
+    instrumentMysql2(pool: unknown): typeof pool;
+    instrumentBetterSqlite3(db: unknown): typeof db;
+    captureQuery<T>(fn: () => Promise<T>, options?: {
+        label?: string;
+    }): Promise<T>;
+}
+declare const RuntimeScope: RuntimeScopeServer;
+
+export { type ConsoleEvent, type DatabaseEvent, type MetricUnit, type NetworkEvent, type PerformanceEvent, RuntimeScope, Sampler, type ServerMetricName, type ServerRuntimeEvent, type ServerSdkConfig, _log, generateId, generateSessionId, getRequestContext, getSessionId, normalizeQuery, parseOperation, parseTablesAccessed, redactParams, runWithContext, runtimeScopeMiddleware };