@blyp/core 0.1.2 → 0.1.22

package/dist/types/connectors/databuddy.d.ts

@@ -0,0 +1,52 @@
+import type { BlypConnectorsConfig, ResolvedDatabuddyConnectorConfig } from '../core/config';
+import type { LogRecord } from '../core/file-logger';
+import type { BlypLogger } from '../core/logger';
+import type { ConnectorMode } from './mode';
+export interface DatabuddyLoggerConfig {
+    connectors?: BlypConnectorsConfig;
+}
+export interface DatabuddyLogger extends BlypLogger {
+}
+export interface DatabuddyExceptionCaptureOptions {
+    properties?: Record<string, unknown>;
+}
+export interface DatabuddyErrorTracker {
+    capture: (error: unknown, options?: DatabuddyExceptionCaptureOptions) => void;
+    child: (bindings: Record<string, unknown>) => DatabuddyErrorTracker;
+}
+export type DatabuddySource = 'server' | 'client';
+export interface DatabuddyTrackEvent {
+    name: string;
+    properties?: Record<string, unknown>;
+    anonymousId?: string;
+    sessionId?: string;
+}
+export interface DatabuddyClientLike {
+    track: (event: DatabuddyTrackEvent) => unknown | Promise<unknown>;
+    flush: () => Promise<unknown>;
+}
+export interface DatabuddySendOptions {
+    source?: DatabuddySource;
+    warnIfUnavailable?: boolean;
+}
+export interface DatabuddyCaptureExceptionOptions {
+    source?: DatabuddySource;
+    warnIfUnavailable?: boolean;
+    properties?: Record<string, unknown>;
+    anonymousId?: string;
+    sessionId?: string;
+}
+export interface DatabuddySender {
+    readonly enabled: boolean;
+    readonly ready: boolean;
+    readonly mode: ConnectorMode;
+    readonly status: 'enabled' | 'missing';
+    shouldAutoForwardServerLogs: () => boolean;
+    shouldAutoCaptureExceptions: () => boolean;
+    send: (record: LogRecord, options?: DatabuddySendOptions) => void;
+    captureException: (error: unknown, options?: DatabuddyCaptureExceptionOptions) => void;
+    flush: () => Promise<void>;
+}
+export interface DatabuddyTestHooks {
+    createClient?: (config: ResolvedDatabuddyConnectorConfig) => DatabuddyClientLike;
+}

package/dist/types/core/config.d.ts

@@ -19,6 +19,59 @@ export interface ClientLoggingConfig {
     enabled?: boolean;
     path?: string;
 }
+export interface RedactionConfig {
+    keys?: string[];
+    paths?: string[];
+    patterns?: RegExp[];
+    disablePatternScanning?: boolean;
+}
+export interface ResolvedRedactionConfig {
+    keys: string[];
+    paths: string[];
+    patterns: RegExp[];
+    disablePatternScanning: boolean;
+}
+export interface ConnectorRetryConfig {
+    maxAttempts?: number;
+    initialBackoffMs?: number;
+    maxBackoffMs?: number;
+    multiplier?: number;
+    jitter?: boolean;
+}
+export interface ResolvedConnectorRetryConfig {
+    maxAttempts: number;
+    initialBackoffMs: number;
+    maxBackoffMs: number;
+    multiplier: number;
+    jitter: boolean;
+}
+export interface ConnectorDeliveryConfig {
+    enabled?: boolean;
+    memoryBufferSize?: number;
+    durableQueuePath?: string;
+    durableSpillStrategy?: 'after-first-failure';
+    memoryBatchSize?: number;
+    sqliteWriteBatchSize?: number;
+    sqliteReadBatchSize?: number;
+    dispatchConcurrency?: number;
+    pollIntervalMs?: number;
+    overflowStrategy?: 'drop-oldest' | 'drop-new';
+    retry?: ConnectorRetryConfig;
+}
+export interface ResolvedConnectorDeliveryConfig {
+    enabled: boolean;
+    memoryBufferSize: number;
+    durableQueuePath: string;
+    durableSpillStrategy: 'after-first-failure';
+    memoryBatchSize: number;
+    sqliteWriteBatchSize: number;
+    sqliteReadBatchSize: number;
+    dispatchConcurrency: number;
+    pollIntervalMs: number;
+    overflowStrategy: 'drop-oldest' | 'drop-new';
+    retry: ResolvedConnectorRetryConfig;
+    durableReady: boolean;
+}
 export interface PostHogConnectorConfig {
     enabled?: boolean;
     mode?: ConnectorMode;
@@ -27,6 +80,20 @@ export interface PostHogConnectorConfig {
     serviceName?: string;
     errorTracking?: PostHogErrorTrackingConfig;
 }
+export interface DatabuddyConnectorConfig {
+    enabled?: boolean;
+    mode?: ConnectorMode;
+    apiKey?: string;
+    websiteId?: string;
+    namespace?: string;
+    source?: string;
+    apiUrl?: string;
+    debug?: boolean;
+    enableBatching?: boolean;
+    batchSize?: number;
+    batchTimeout?: number;
+    maxQueueSize?: number;
+}
 export interface BetterStackConnectorConfig {
     enabled?: boolean;
     mode?: ConnectorMode;
@@ -62,6 +129,22 @@ export interface ResolvedPostHogConnectorConfig {
     serviceName: string;
     errorTracking: ResolvedPostHogErrorTrackingConfig;
 }
+export interface ResolvedDatabuddyConnectorConfig {
+    enabled: boolean;
+    mode: ConnectorMode;
+    apiKey?: string;
+    websiteId?: string;
+    namespace?: string;
+    source?: string;
+    apiUrl?: string;
+    debug: boolean;
+    enableBatching: boolean;
+    batchSize?: number;
+    batchTimeout?: number;
+    maxQueueSize?: number;
+    ready: boolean;
+    status: 'enabled' | 'missing';
+}
 export interface ResolvedBetterStackConnectorConfig {
     enabled: boolean;
     mode: ConnectorMode;
@@ -119,9 +202,11 @@ export interface ResolvedOTLPConnectorConfig {
 }
 export interface BlypConnectorsConfig {
     betterstack?: BetterStackConnectorConfig;
+    databuddy?: DatabuddyConnectorConfig;
     posthog?: PostHogConnectorConfig;
     sentry?: SentryConnectorConfig;
     otlp?: OTLPConnectorConfig[];
+    delivery?: ConnectorDeliveryConfig;
 }
 export interface BlypConfig {
     pretty: boolean;
@@ -131,19 +216,23 @@ export interface BlypConfig {
     file?: LogFileConfig;
     database?: DatabaseLoggerConfig;
     clientLogging?: ClientLoggingConfig;
+    redact?: RedactionConfig;
     connectors?: BlypConnectorsConfig;
 }
 export interface ResolvedBlypConnectorsConfig {
     betterstack: ResolvedBetterStackConnectorConfig;
+    databuddy: ResolvedDatabuddyConnectorConfig;
     posthog: ResolvedPostHogConnectorConfig;
     sentry: ResolvedSentryConnectorConfig;
     otlp: ResolvedOTLPConnectorConfig[];
+    delivery: ResolvedConnectorDeliveryConfig;
 }
 export interface ResolvedBlypConfig extends BlypConfig {
     destination: BlypDestination;
     file: Required<LogFileConfig>;
     database?: ResolvedDatabaseLoggerConfig;
     clientLogging: Required<ClientLoggingConfig>;
+    redact: ResolvedRedactionConfig;
     connectors: ResolvedBlypConnectorsConfig;
 }
 export interface ConfigFileMatch {

package/dist/types/core/logger.d.ts

@@ -1,9 +1,11 @@
 import type { BetterStackSender } from '../connectors/betterstack';
+import type { DatabuddySender } from '../connectors/databuddy';
 import type { PostHogSender } from '../connectors/posthog';
 import type { SentrySender } from '../connectors/sentry';
 import type { OTLPRegistry } from '../connectors/otlp';
 import type { BlypPrimarySink } from '../../core/primary-sink';
 import type { StructuredLog, StructuredLogPayload } from './structured-log';
+import type { ResolvedRedactionConfig } from './config';
 export interface BlypLogger {
     success: (message: unknown, ...args: unknown[]) => void;
     critical: (message: unknown, ...args: unknown[]) => void;
@@ -24,13 +26,16 @@ export interface StructuredLogFactoryOptions {
     resolveDefaultFields?: () => Record<string, unknown>;
     onCreate?: () => void;
     onEmit?: (payload: StructuredLogPayload) => void;
+    redact?: ResolvedRedactionConfig;
 }
 export interface LoggerFactoryHandle {
     bindings: Record<string, unknown>;
     betterstack: BetterStackSender;
+    databuddy: DatabuddySender;
     posthog: PostHogSender;
     sentry: SentrySender;
     otlp: OTLPRegistry;
+    redact: ResolvedRedactionConfig;
     sink: BlypPrimarySink;
     create: (source: InternalLoggerSource, bindings?: Record<string, unknown>) => BlypLogger;
     writeStructured: (payload: StructuredLogPayload, message: string, source?: InternalLoggerSource) => void;

package/dist/types/core/structured-log.d.ts

@@ -1,3 +1,4 @@
+import type { ResolvedRedactionConfig } from './config';
 export type StructuredLogLevel = 'debug' | 'info' | 'warn' | 'warning' | 'error' | 'success' | 'critical' | 'table';
 export interface StructuredLogError {
     message: string;
@@ -54,4 +55,5 @@ export interface CreateStructuredLogOptions {
     write(payload: StructuredLogPayload<Record<string, unknown>>, message: string): void;
     onCreate?: () => void;
     onEmit?: (payload: StructuredLogPayload<Record<string, unknown>>) => void;
+    redact?: ResolvedRedactionConfig;
 }

package/dist/types/database.d.ts

@@ -58,6 +58,7 @@ export interface DatabaseLogRow {
     message: string;
     caller: string | null;
     type: string | null;
+    traceId: string | null;
     groupId: string | null;
     method: string | null;
     path: string | null;

package/dist/types/frameworks/astro.d.ts

@@ -0,0 +1,33 @@
+import type { BlypLogger } from '../../core/logger';
+import type { ClientLogIngestionConfig as SharedClientLogIngestionConfig, HttpRequestLog, ServerLoggerConfig } from './shared';
+export interface AstroLocals {
+    blypLog?: BlypLogger;
+    blypTraceId?: string;
+    [key: string]: unknown;
+}
+export interface AstroEndpointContext {
+    request: Request;
+    url: URL;
+    params?: Record<string, string>;
+    locals: AstroLocals;
+    [key: string]: unknown;
+}
+export type AstroMiddlewareContext = AstroEndpointContext;
+export type AstroMiddlewareNext = () => Response | Promise<Response>;
+export type AstroMiddlewareHandler = (context: AstroMiddlewareContext, next: AstroMiddlewareNext) => Response | Promise<Response>;
+export type AstroEndpointHandler = (context: AstroEndpointContext) => Response | Promise<Response>;
+export interface AstroLoggerContext {
+    context: AstroEndpointContext;
+    response?: Response;
+    error?: unknown;
+}
+export interface AstroLoggerConfig extends ServerLoggerConfig<AstroLoggerContext> {
+}
+export interface AstroClientLogIngestionConfig extends SharedClientLogIngestionConfig<AstroLoggerContext> {
+}
+export interface AstroLoggerFactory {
+    logger: BlypLogger;
+    onRequest: AstroMiddlewareHandler;
+    clientLogHandler: AstroEndpointHandler;
+}
+export type { HttpRequestLog };

package/dist/types/frameworks/client.d.ts

@@ -4,6 +4,7 @@ export interface ClientLoggerState {
     readonly pageId: string;
     readonly sessionId: string;
     readonly bindings: Record<string, unknown>;
+    readonly traceId?: string;
     readonly delivery?: {
         enqueue: (event: ClientLogEvent) => void;
     };
@@ -17,6 +18,7 @@ export interface ClientLoggerConfig {
     connector?: ClientConnectorRequest;
     metadata?: Record<string, unknown> | (() => Record<string, unknown>);
     delivery?: RemoteDeliveryConfig;
+    traceId?: string;
 }
 export interface ClientLogger {
     success: (message: unknown, ...args: unknown[]) => void;

package/dist/types/frameworks/elysia.d.ts

@@ -5,6 +5,7 @@ export interface ElysiaContext {
     startTime?: number;
     request: Request;
     path: string;
+    blypTraceId?: string;
     params?: Record<string, string>;
     query?: Record<string, string>;
     headers: Record<string, string | undefined>;
@@ -29,5 +30,6 @@ export interface ElysiaLoggerConfig extends ServerLoggerConfig<ElysiaContext> {
 }
 export interface ElysiaClientLogIngestionConfig extends SharedClientLogIngestionConfig<ElysiaContext> {
 }
+export type ElysiaLoggerPlugin = any;
 export type LoggerConfig = ElysiaLoggerConfig;
 export type ClientLogIngestionConfig = ElysiaClientLogIngestionConfig;

package/dist/types/frameworks/express.d.ts

@@ -16,6 +16,7 @@ export type { HttpRequestLog };
 declare module 'express-serve-static-core' {
     interface Request {
         blypLog: BlypLogger;
+        blypTraceId?: string;
     }
     interface Locals {
         blypStartTime?: number;

package/dist/types/frameworks/fastify.d.ts

@@ -15,6 +15,7 @@ export type { HttpRequestLog };
 declare module 'fastify' {
     interface FastifyRequest {
         blypLog: BlypLogger;
+        blypTraceId?: string;
         blypStartTime?: number;
         blypError?: unknown;
         blypStructuredLogEmitted?: boolean;

package/dist/types/frameworks/hono.d.ts

@@ -3,6 +3,7 @@ import type { BlypLogger } from '../../core/logger';
 import type { ClientLogIngestionConfig as SharedClientLogIngestionConfig, HttpRequestLog, ServerLoggerConfig } from './shared';
 export interface HonoLoggerVariables {
     blypLog: BlypLogger;
+    blypTraceId?: string;
     blypStartTime?: number;
 }
 export interface HonoLoggerConfig extends ServerLoggerConfig<Context> {

package/dist/types/frameworks/http.d.ts

@@ -32,6 +32,7 @@ export interface HttpRequestLog {
     origin?: string;
     referer?: string;
     acceptLanguage?: string;
+    headers?: HeaderRecord;
     client?: {
         ip?: string;
         hostname?: string;

package/dist/types/frameworks/nestjs.d.ts

@@ -24,6 +24,7 @@ export type { HttpRequestLog };
 declare module 'express-serve-static-core' {
     interface Request {
         blypLog: BlypLogger;
+        blypTraceId?: string;
         blypStartTime?: number;
         blypStructuredLogEmitted?: boolean;
     }
@@ -31,6 +32,7 @@ declare module 'express-serve-static-core' {
 declare module 'fastify' {
     interface FastifyRequest {
         blypLog: BlypLogger;
+        blypTraceId?: string;
         blypStartTime?: number;
         blypStructuredLogEmitted?: boolean;
     }

package/dist/types/frameworks/nextjs.d.ts

@@ -6,6 +6,7 @@ export interface NextJsRouteContext {
 }
 export interface NextJsLoggerHelpers {
     log: BlypLogger;
+    traceId: string;
 }
 export interface NextJsLoggerContext {
     request: Request;

package/dist/types/frameworks/nitro.d.ts

@@ -0,0 +1,63 @@
+import type { BlypLogger } from '../../core/logger';
+import type { ClientLogIngestionConfig as SharedClientLogIngestionConfig, HttpRequestLog, ServerLoggerConfig } from './shared';
+import type { HeaderRecord } from './http';
+export interface NitroNodeRequestLike extends AsyncIterable<Uint8Array | string> {
+    method?: string;
+    url?: string;
+    headers?: HeaderRecord;
+}
+export interface NitroNodeResponseLike {
+    statusCode?: number;
+}
+export interface NitroNodeLike {
+    req?: NitroNodeRequestLike;
+    res?: NitroNodeResponseLike;
+}
+export interface NitroEventContext {
+    blypLog?: BlypLogger;
+    blypTraceId?: string;
+    [key: string | symbol]: unknown;
+}
+export interface NitroEventLike {
+    path?: string;
+    method?: string;
+    headers?: Headers | HeaderRecord | {
+        get(name: string): string | null;
+    };
+    url?: string;
+    node?: NitroNodeLike;
+    context: NitroEventContext;
+    request?: Request;
+    body?: unknown;
+    [key: string]: unknown;
+}
+export interface NitroResponseLike {
+    status?: number;
+    statusCode?: number;
+    body?: unknown;
+    headers?: HeadersInit;
+}
+export interface NitroHooksLike {
+    hook: (name: string, callback: (...args: unknown[]) => unknown) => void | Promise<void>;
+}
+export interface NitroAppLike {
+    hooks: NitroHooksLike;
+}
+export type NitroLoggerPlugin = (nitroApp: NitroAppLike) => void | Promise<void>;
+export type NitroEventHandler = (event: NitroEventLike) => Response | Promise<Response>;
+export interface NitroLoggerContext {
+    event: NitroEventLike;
+    response?: NitroResponseLike | Response;
+    error?: unknown;
+}
+export interface NitroLoggerConfig extends ServerLoggerConfig<NitroLoggerContext> {
+}
+export interface NitroClientLogIngestionConfig extends SharedClientLogIngestionConfig<NitroLoggerContext> {
+}
+export interface NitroLoggerFactory {
+    logger: BlypLogger;
+    plugin: NitroLoggerPlugin;
+    clientLogHandler: NitroEventHandler;
+    getLogger: (event: NitroEventLike) => BlypLogger;
+}
+export type { HttpRequestLog };

package/dist/types/frameworks/nuxt.d.ts

@@ -0,0 +1,12 @@
+import type { BlypLogger } from '../../core/logger';
+import type { HttpRequestLog } from './shared';
+import type { NitroClientLogIngestionConfig as NuxtClientLogIngestionConfig, NitroEventHandler as NuxtEventHandler, NitroEventLike as NuxtEventLike, NitroLoggerConfig as BaseNuxtLoggerConfig, NitroLoggerPlugin as NuxtLoggerPlugin, NitroLoggerContext } from './nitro';
+export interface NuxtLoggerConfig extends BaseNuxtLoggerConfig {
+}
+export interface NuxtLoggerFactory {
+    logger: BlypLogger;
+    serverPlugin: NuxtLoggerPlugin;
+    clientLogHandler: NuxtEventHandler;
+    getLogger: (event: NuxtEventLike) => BlypLogger;
+}
+export type { HttpRequestLog, NitroLoggerContext as NuxtLoggerContext, NuxtClientLogIngestionConfig, NuxtEventHandler, NuxtEventLike, NuxtLoggerPlugin, };

package/dist/types/frameworks/react-router.d.ts

@@ -0,0 +1,35 @@
+import type { BlypLogger } from '../../core/logger';
+import type { ClientLogIngestionConfig as SharedClientLogIngestionConfig, HttpRequestLog, ServerLoggerConfig } from './shared';
+export interface ReactRouterContextStore {
+    get?: (key: unknown) => unknown;
+    set?: (key: unknown, value: unknown) => void;
+    [key: string | symbol]: unknown;
+}
+export interface ReactRouterMiddlewareArgs {
+    request: Request;
+    params?: Record<string, string | undefined>;
+    context: ReactRouterContextStore;
+}
+export type ReactRouterMiddlewareNext = () => Response | Promise<Response>;
+export type ReactRouterLoggerMiddleware = (args: ReactRouterMiddlewareArgs, next: ReactRouterMiddlewareNext) => Response | Promise<Response>;
+export interface ReactRouterLoggerContext {
+    request: Request;
+    params?: Record<string, string | undefined>;
+    context: ReactRouterContextStore;
+    response?: Response;
+    error?: unknown;
+}
+export interface ReactRouterLoggerConfig extends ServerLoggerConfig<ReactRouterLoggerContext> {
+}
+export interface ReactRouterClientLogIngestionConfig extends SharedClientLogIngestionConfig<ReactRouterLoggerContext> {
+}
+export interface ReactRouterLoggerFactory {
+    logger: BlypLogger;
+    middleware: ReactRouterLoggerMiddleware;
+    clientLogHandler: (request: Request) => Promise<Response>;
+    getLogger: (context: ReactRouterContextStore) => BlypLogger;
+    setLogger: (context: ReactRouterContextStore, logger: BlypLogger) => void;
+    getTraceId: (context: ReactRouterContextStore) => string | undefined;
+    setTraceId: (context: ReactRouterContextStore, traceId: string) => void;
+}
+export type { HttpRequestLog };

package/dist/types/frameworks/request-context.d.ts

@@ -5,4 +5,5 @@ export interface BlypRequestContextStore {
     structuredLogEmitted: boolean;
     mixedLoggerWarningShown: boolean;
     activeLogger?: BlypLogger;
+    traceId?: string;
 }

package/dist/types/frameworks/shared.d.ts

@@ -1,4 +1,4 @@
-import type { BlypConfig, BlypConnectorsConfig, BlypDestination, DatabaseLoggerConfig, LogFileConfig } from '../core/config';
+import type { BlypConfig, BlypConnectorsConfig, BlypDestination, DatabaseLoggerConfig, LogFileConfig, RedactionConfig } from '../core/config';
 import type { BlypLogger } from '../core/logger';
 import type { ClientLogEvent } from '../shared/client-log';
 import type { ConnectorMode } from '../connectors/mode';
@@ -19,8 +19,10 @@ export interface ServerLoggerConfig<Ctx> {
     };
     customProps?: (ctx: Ctx) => Record<string, unknown>;
     logErrors?: boolean;
+    includePaths?: string[];
     ignorePaths?: string[];
     clientLogging?: boolean | ClientLogIngestionConfig<Ctx>;
+    redact?: RedactionConfig;
     connectors?: BlypConnectorsConfig;
 }
 export interface ResolvedPostHogConnector {
@@ -86,6 +88,29 @@ export interface ResolvedBetterStackConnector {
         context?: Record<string, unknown>;
     }) => void;
 }
+export interface ResolvedDatabuddyConnector {
+    enabled: boolean;
+    ready: boolean;
+    mode: ConnectorMode;
+    status: 'enabled' | 'missing';
+    shouldAutoCaptureExceptions: () => boolean;
+    send: (record: {
+        timestamp: string;
+        level: string;
+        message: string;
+        [key: string]: unknown;
+    }, options?: {
+        source?: 'server' | 'client';
+        warnIfUnavailable?: boolean;
+    }) => void;
+    captureException: (error: unknown, options?: {
+        source?: 'server' | 'client';
+        warnIfUnavailable?: boolean;
+        properties?: Record<string, unknown>;
+        anonymousId?: string;
+        sessionId?: string;
+    }) => void;
+}
 export interface ResolvedSentryConnector {
     enabled: boolean;
     ready: boolean;
@@ -136,6 +161,7 @@ export interface ResolvedOTLPRegistry {
 export interface ResolvedServerLogger<Ctx> {
     logger: BlypLogger;
     betterstack: ResolvedBetterStackConnector;
+    databuddy: ResolvedDatabuddyConnector;
     posthog: ResolvedPostHogConnector;
     sentry: ResolvedSentryConnector;
     otlp: ResolvedOTLPRegistry;
@@ -147,6 +173,7 @@ export interface ResolvedServerLogger<Ctx> {
     autoLogging: ServerLoggerConfig<Ctx>['autoLogging'];
     customProps?: (ctx: Ctx) => Record<string, unknown>;
     logErrors: boolean;
+    resolvedIncludePaths?: string[];
     resolvedIgnorePaths?: string[];
     resolvedClientLogging: ClientLogIngestionConfig<Ctx> | null;
     ingestionPath: string;

package/dist/types/frameworks/standalone.d.ts

@@ -1,5 +1,5 @@
 import type { BlypLogger } from '../core/logger';
-import type { BlypDestination, BlypConnectorsConfig, ClientLoggingConfig, DatabaseLoggerConfig, LogFileConfig, LogRotationConfig } from '../core/config';
+import type { BlypDestination, BlypConnectorsConfig, ClientLoggingConfig, DatabaseLoggerConfig, LogFileConfig, LogRotationConfig, RedactionConfig } from '../core/config';
 export type LogLevel = 'error' | 'critical' | 'warning' | 'info' | 'success' | 'debug' | 'table';
 export interface StandaloneLoggerConfig {
     pretty?: boolean;
@@ -9,6 +9,7 @@ export interface StandaloneLoggerConfig {
     file?: LogFileConfig;
     database?: DatabaseLoggerConfig;
     clientLogging?: ClientLoggingConfig;
+    redact?: RedactionConfig;
     connectors?: BlypConnectorsConfig;
 }
 export interface StandaloneLogger extends BlypLogger {
@@ -18,7 +19,7 @@ export interface StandaloneLogger extends BlypLogger {
     warn: (message: unknown, ...args: unknown[]) => void;
     warning: (message: unknown, ...args: unknown[]) => void;
 }
-export type { BlypConnectorsConfig, BlypDestination, ClientLoggingConfig, DatabaseLoggerConfig, LogFileConfig, LogRotationConfig, };
+export type { BlypConnectorsConfig, BlypDestination, ClientLoggingConfig, DatabaseLoggerConfig, LogFileConfig, LogRotationConfig, RedactionConfig, };
 export type RuntimeType = 'bun' | 'node';
 export interface RuntimeAdapter {
     readonly type: RuntimeType;

package/dist/types/frameworks/sveltekit.d.ts

@@ -2,6 +2,7 @@ import type { BlypLogger } from '../../core/logger';
 import type { ClientLogIngestionConfig as SharedClientLogIngestionConfig, HttpRequestLog, ServerLoggerConfig } from './shared';
 export interface SvelteKitLocals {
     blypLog?: BlypLogger;
+    blypTraceId?: string;
     [key: string]: unknown;
 }
 export interface SvelteKitRequestEvent {

package/dist/types/frameworks/tanstack-start.d.ts

@@ -2,14 +2,20 @@ import type { BlypLogger } from '../../core/logger';
 import type { ClientLogIngestionConfig as SharedClientLogIngestionConfig, HttpRequestLog, ServerLoggerConfig } from './shared';
 export interface TanStackStartMiddlewareContext {
     request: Request;
-    context: Record<string, unknown>;
+    context: Record<string, unknown> & {
+        blypTraceId?: string;
+    };
     next: (options?: {
-        context?: Record<string, unknown>;
+        context?: Record<string, unknown> & {
+            blypTraceId?: string;
+        };
     }) => Promise<Response>;
 }
 export interface TanStackStartLoggerContext {
     request: Request;
-    context: Record<string, unknown>;
+    context: Record<string, unknown> & {
+        blypTraceId?: string;
+    };
     response?: Response;
     error?: unknown;
 }

package/dist/types/frameworks/workers.d.ts

@@ -1,12 +1,15 @@
+import type { RedactionConfig, ResolvedRedactionConfig } from '../core/config';
 import type { HttpRequestLog } from './http';
 import type { StructuredLog } from '../core/structured-log';
 export interface WorkersLoggerConfig {
     env?: Record<string, unknown>;
     customProps?: (request: Request) => Record<string, unknown>;
+    redact?: RedactionConfig;
 }
 export interface WorkersLoggerState {
     env?: Record<string, unknown>;
     customProps?: (request: Request) => Record<string, unknown>;
+    redact?: ResolvedRedactionConfig;
 }
 export type WorkersConsoleMethod = 'debug' | 'info' | 'warn' | 'error' | 'log';
 export type WorkersLogLevel = 'debug' | 'info' | 'warn' | 'warning' | 'error' | 'success' | 'critical';

package/dist/types/shared/client-log.d.ts

@@ -24,7 +24,7 @@ export interface ClientLogSessionContext {
     pageId: string;
     sessionId: string;
 }
-export type ClientConnectorRequest = 'betterstack' | 'posthog' | 'sentry' | {
+export type ClientConnectorRequest = 'betterstack' | 'databuddy' | 'posthog' | 'sentry' | {
     type: 'otlp';
     name: string;
 };
@@ -32,6 +32,7 @@ export interface ClientLogEvent {
     type: 'client_log';
     source: 'client';
     id: string;
+    traceId?: string;
     level: ClientLogLevel;
     message: string;
     connector?: ClientConnectorRequest;