@blyp/core 0.1.21 → 0.1.23

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;
@@ -153,6 +206,7 @@ export interface BlypConnectorsConfig {
     posthog?: PostHogConnectorConfig;
     sentry?: SentryConnectorConfig;
     otlp?: OTLPConnectorConfig[];
+    delivery?: ConnectorDeliveryConfig;
 }
 export interface BlypConfig {
     pretty: boolean;
@@ -162,6 +216,7 @@ export interface BlypConfig {
     file?: LogFileConfig;
     database?: DatabaseLoggerConfig;
     clientLogging?: ClientLoggingConfig;
+    redact?: RedactionConfig;
     connectors?: BlypConnectorsConfig;
 }
 export interface ResolvedBlypConnectorsConfig {
@@ -170,12 +225,14 @@ export interface ResolvedBlypConnectorsConfig {
     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

@@ -5,6 +5,7 @@ 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;
@@ -25,6 +26,7 @@ export interface StructuredLogFactoryOptions {
     resolveDefaultFields?: () => Record<string, unknown>;
     onCreate?: () => void;
     onEmit?: (payload: StructuredLogPayload) => void;
+    redact?: ResolvedRedactionConfig;
 }
 export interface LoggerFactoryHandle {
     bindings: Record<string, unknown>;
@@ -33,6 +35,7 @@ export interface LoggerFactoryHandle {
     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

@@ -2,6 +2,7 @@ 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 {

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

@@ -15,6 +15,7 @@ export interface NitroNodeLike {
 }
 export interface NitroEventContext {
     blypLog?: BlypLogger;
+    blypTraceId?: string;
     [key: string | symbol]: unknown;
 }
 export interface NitroEventLike {

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

@@ -29,5 +29,7 @@ export interface ReactRouterLoggerFactory {
     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 {
@@ -171,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

@@ -32,6 +32,7 @@ export interface ClientLogEvent {
     type: 'client_log';
     source: 'client';
     id: string;
+    traceId?: string;
     level: ClientLogLevel;
     message: string;
     connector?: ClientConnectorRequest;