@blyp/core 0.1.2

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

@@ -0,0 +1,33 @@
+import type { BlypErrorLike } from '../shared/errors';
+import type { ResolveCtx } from '../core/helpers';
+import type { ClientLogIngestionConfig as SharedClientLogIngestionConfig, HttpRequestLog, ServerLoggerConfig } from './shared';
+export interface ElysiaContext {
+    startTime?: number;
+    request: Request;
+    path: string;
+    params?: Record<string, string>;
+    query?: Record<string, string>;
+    headers: Record<string, string | undefined>;
+    set: {
+        status?: number | string;
+        headers?: Record<string, string>;
+        redirect?: string;
+        cookie?: Record<string, unknown>;
+    };
+    error?: BlypErrorLike;
+    code?: string;
+    body?: unknown;
+    cookie?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export type { ResolveCtx, HttpRequestLog };
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export interface ArrowMapping {
+    [key: string]: string;
+}
+export interface ElysiaLoggerConfig extends ServerLoggerConfig<ElysiaContext> {
+}
+export interface ElysiaClientLogIngestionConfig extends SharedClientLogIngestionConfig<ElysiaContext> {
+}
+export type LoggerConfig = ElysiaLoggerConfig;
+export type ClientLogIngestionConfig = ElysiaClientLogIngestionConfig;

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

@@ -0,0 +1,44 @@
+import type { ClientConnectorRequest, ClientLogBrowserContext, ClientLogDeviceContext, ClientLogEvent, ClientLogLevel, ClientLogPageContext, RemoteDeliveryConfig, RemoteDeliveryDropContext, RemoteDeliveryFailureContext, RemoteDeliveryFailureReason, RemoteDeliveryRetryContext, RemoteDeliverySuccessContext } from '../shared/client-log';
+export interface ExpoLoggerState {
+    readonly pageId: string;
+    readonly sessionId: string;
+    readonly bindings: Record<string, unknown>;
+    readonly delivery?: {
+        enqueue: (event: ClientLogEvent) => void;
+    };
+}
+export type ExpoLogLevel = 'warn' | 'debug' | 'info' | 'warning' | 'error' | 'critical' | 'success' | 'table';
+export interface ExpoNetworkSubscription {
+    remove: () => void;
+}
+export interface ExpoNetworkState {
+    type?: unknown;
+    isConnected?: unknown;
+    isInternetReachable?: unknown;
+}
+export interface ExpoNetworkModule {
+    getNetworkStateAsync: () => Promise<ExpoNetworkState>;
+    addNetworkStateListener?: (listener: (event: ExpoNetworkState) => void) => ExpoNetworkSubscription;
+}
+export type ExpoNetworkLoader = () => Promise<ExpoNetworkModule | null>;
+export interface ExpoLoggerConfig {
+    endpoint: string;
+    headers?: Record<string, string>;
+    localConsole?: boolean;
+    remoteSync?: boolean;
+    connector?: ClientConnectorRequest;
+    metadata?: Record<string, unknown> | (() => Record<string, unknown>);
+    delivery?: RemoteDeliveryConfig;
+}
+export interface ExpoLogger {
+    success: (message: unknown, ...args: unknown[]) => void;
+    critical: (message: unknown, ...args: unknown[]) => void;
+    warning: (message: unknown, ...args: unknown[]) => void;
+    info: (message: unknown, ...args: unknown[]) => void;
+    debug: (message: unknown, ...args: unknown[]) => void;
+    error: (message: unknown, ...args: unknown[]) => void;
+    warn: (message: unknown, ...args: unknown[]) => void;
+    table: (message: string, data?: unknown) => void;
+    child: (bindings: Record<string, unknown>) => ExpoLogger;
+}
+export type { ClientLogBrowserContext, ClientConnectorRequest, ClientLogDeviceContext, ClientLogEvent, ClientLogLevel, ClientLogPageContext, RemoteDeliveryConfig, RemoteDeliveryDropContext, RemoteDeliveryFailureContext, RemoteDeliveryFailureReason, RemoteDeliveryRetryContext, RemoteDeliverySuccessContext, };

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

@@ -0,0 +1,24 @@
+import type { ErrorRequestHandler, Request, RequestHandler, Response } from 'express';
+import type { BlypLogger } from '../../core/logger';
+import type { ClientLogIngestionConfig as SharedClientLogIngestionConfig, HttpRequestLog, ServerLoggerConfig } from './shared';
+export interface ExpressLoggerContext {
+    req: Request;
+    res: Response;
+    error?: unknown;
+}
+export interface ExpressLoggerConfig extends ServerLoggerConfig<ExpressLoggerContext> {
+}
+export interface ExpressClientLogIngestionConfig extends SharedClientLogIngestionConfig<ExpressLoggerContext> {
+}
+export type ExpressLoggerMiddleware = RequestHandler;
+export type ExpressErrorLoggerMiddleware = ErrorRequestHandler;
+export type { HttpRequestLog };
+declare module 'express-serve-static-core' {
+    interface Request {
+        blypLog: BlypLogger;
+    }
+    interface Locals {
+        blypStartTime?: number;
+        blypError?: unknown;
+    }
+}

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

@@ -0,0 +1,22 @@
+import type { FastifyPluginAsync } from 'fastify';
+import type { BlypLogger } from '../../core/logger';
+import type { ClientLogIngestionConfig as SharedClientLogIngestionConfig, HttpRequestLog, ServerLoggerConfig } from './shared';
+export interface FastifyLoggerContext {
+    request: import('fastify').FastifyRequest;
+    reply: import('fastify').FastifyReply;
+    error?: unknown;
+}
+export interface FastifyLoggerConfig extends ServerLoggerConfig<FastifyLoggerContext> {
+}
+export interface FastifyClientLogIngestionConfig extends SharedClientLogIngestionConfig<FastifyLoggerContext> {
+}
+export type FastifyLoggerPlugin = FastifyPluginAsync;
+export type { HttpRequestLog };
+declare module 'fastify' {
+    interface FastifyRequest {
+        blypLog: BlypLogger;
+        blypStartTime?: number;
+        blypError?: unknown;
+        blypStructuredLogEmitted?: boolean;
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { Context, MiddlewareHandler } from 'hono';
+import type { BlypLogger } from '../../core/logger';
+import type { ClientLogIngestionConfig as SharedClientLogIngestionConfig, HttpRequestLog, ServerLoggerConfig } from './shared';
+export interface HonoLoggerVariables {
+    blypLog: BlypLogger;
+    blypStartTime?: number;
+}
+export interface HonoLoggerConfig extends ServerLoggerConfig<Context> {
+}
+export interface HonoClientLogIngestionConfig extends SharedClientLogIngestionConfig<Context> {
+}
+export type HonoLoggerMiddleware = MiddlewareHandler;
+export type { HttpRequestLog };

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

@@ -0,0 +1,47 @@
+import type { BlypErrorLike } from '../shared/errors';
+export type HeaderRecord = Record<string, string | string[] | undefined>;
+export interface RequestLike {
+    method: string;
+    url: string;
+    headers?: Headers | HeaderRecord | {
+        get(name: string): string | null;
+    };
+}
+export interface ErrorLike extends BlypErrorLike {
+}
+export interface ResolveLike {
+    set?: {
+        status?: number | string;
+    };
+    error?: ErrorLike;
+    code?: string | number;
+    statusCode?: number;
+}
+export interface HttpRequestLog {
+    type: 'http_request' | 'http_error';
+    method: string;
+    url: string;
+    statusCode: number;
+    responseTime: number;
+    hostname?: string;
+    ip?: string;
+    forwardedFor?: string[];
+    protocol?: string;
+    port?: string;
+    userAgent?: string;
+    origin?: string;
+    referer?: string;
+    acceptLanguage?: string;
+    client?: {
+        ip?: string;
+        hostname?: string;
+        browser?: string;
+        os?: string;
+        deviceType?: 'desktop' | 'mobile' | 'tablet' | 'bot' | 'unknown';
+        platform?: string;
+        isMobile?: boolean;
+    };
+    error?: string;
+    stack?: string;
+    [key: string]: unknown;
+}

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

@@ -0,0 +1,37 @@
+import type { ExecutionContext } from '@nestjs/common';
+import type { BlypLogger } from '../core/logger';
+import type { StandaloneLogger } from './standalone';
+import type { ClientLogIngestionConfig as SharedClientLogIngestionConfig, HttpRequestLog, ResolvedServerLogger, ServerLoggerConfig } from './shared';
+export type NestAdapterType = 'express' | 'fastify';
+export type NestHeaderRecord = Record<string, string | string[] | undefined>;
+export interface NestLoggerState extends Omit<ResolvedServerLogger<NestLoggerContext>, 'logger'> {
+    logger: StandaloneLogger;
+}
+export interface NestLoggerContext {
+    request: unknown;
+    response: unknown;
+    adapterType: NestAdapterType;
+    executionContext?: ExecutionContext;
+    error?: unknown;
+    controllerName?: string;
+    handlerName?: string;
+}
+export interface NestLoggerConfig extends ServerLoggerConfig<NestLoggerContext> {
+}
+export interface NestClientLogIngestionConfig extends SharedClientLogIngestionConfig<NestLoggerContext> {
+}
+export type { HttpRequestLog };
+declare module 'express-serve-static-core' {
+    interface Request {
+        blypLog: BlypLogger;
+        blypStartTime?: number;
+        blypStructuredLogEmitted?: boolean;
+    }
+}
+declare module 'fastify' {
+    interface FastifyRequest {
+        blypLog: BlypLogger;
+        blypStartTime?: number;
+        blypStructuredLogEmitted?: boolean;
+    }
+}

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

@@ -0,0 +1,27 @@
+import type { BlypLogger } from '../../core/logger';
+import type { ClientLogIngestionConfig as SharedClientLogIngestionConfig, HttpRequestLog, ServerLoggerConfig } from './shared';
+export interface NextJsRouteContext {
+    params?: Record<string, string> | Promise<Record<string, string>>;
+    [key: string]: unknown;
+}
+export interface NextJsLoggerHelpers {
+    log: BlypLogger;
+}
+export interface NextJsLoggerContext {
+    request: Request;
+    context?: NextJsRouteContext;
+    response?: Response;
+    error?: unknown;
+}
+export interface NextJsLoggerConfig extends ServerLoggerConfig<NextJsLoggerContext> {
+}
+export interface NextJsClientLogIngestionConfig extends SharedClientLogIngestionConfig<NextJsLoggerContext> {
+}
+export type NextJsWrappedHandler<Ctx extends NextJsRouteContext = NextJsRouteContext> = (request: Request, context: Ctx) => Response | Promise<Response>;
+export type NextJsHandlerWithLogger<Ctx extends NextJsRouteContext = NextJsRouteContext> = (request: Request, context: Ctx, helpers: NextJsLoggerHelpers) => Response | Promise<Response>;
+export interface NextJsLoggerFactory {
+    logger: BlypLogger;
+    withLogger: <Ctx extends NextJsRouteContext = NextJsRouteContext>(handler: NextJsHandlerWithLogger<Ctx>) => NextJsWrappedHandler<Ctx>;
+    clientLogHandler: (request: Request) => Promise<Response>;
+}
+export type { HttpRequestLog };

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

@@ -0,0 +1,8 @@
+import type { BlypLogger } from '../core/logger';
+export interface BlypRequestContextStore {
+    requestScopedLoggerActive: boolean;
+    structuredCollectorActive: boolean;
+    structuredLogEmitted: boolean;
+    mixedLoggerWarningShown: boolean;
+    activeLogger?: BlypLogger;
+}

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

@@ -0,0 +1,8 @@
+export interface RequestScopedLoggerOptions {
+    resolveStructuredFields?: () => Record<string, unknown>;
+    onStructuredEmit?: () => void;
+}
+export interface HttpErrorCaptureContext {
+    error?: unknown;
+    distinctId?: string;
+}

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

@@ -0,0 +1,154 @@
+import type { BlypConfig, BlypConnectorsConfig, BlypDestination, DatabaseLoggerConfig, LogFileConfig } from '../core/config';
+import type { BlypLogger } from '../core/logger';
+import type { ClientLogEvent } from '../shared/client-log';
+import type { ConnectorMode } from '../connectors/mode';
+export interface ClientLogIngestionConfig<Ctx> {
+    path?: string;
+    validate?: (ctx: Ctx, payload: ClientLogEvent) => boolean | Promise<boolean>;
+    enrich?: (ctx: Ctx, payload: ClientLogEvent) => Record<string, unknown> | Promise<Record<string, unknown>>;
+}
+export interface ServerLoggerConfig<Ctx> {
+    level?: string;
+    pretty?: boolean;
+    destination?: BlypDestination;
+    logDir?: string;
+    file?: LogFileConfig;
+    database?: DatabaseLoggerConfig;
+    autoLogging?: boolean | {
+        ignore?: (ctx: Ctx) => boolean;
+    };
+    customProps?: (ctx: Ctx) => Record<string, unknown>;
+    logErrors?: boolean;
+    ignorePaths?: string[];
+    clientLogging?: boolean | ClientLogIngestionConfig<Ctx>;
+    connectors?: BlypConnectorsConfig;
+}
+export interface ResolvedPostHogConnector {
+    enabled: boolean;
+    ready: boolean;
+    mode: ConnectorMode;
+    serviceName: string;
+    host: string;
+    status: 'enabled' | 'missing';
+    errorTracking: {
+        enabled: boolean;
+        ready: boolean;
+        mode: ConnectorMode;
+        status: 'enabled' | 'missing';
+        enableExceptionAutocapture: boolean;
+    };
+    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;
+        distinctId?: string;
+        properties?: Record<string, unknown>;
+    }) => void;
+}
+export interface ResolvedBetterStackConnector {
+    enabled: boolean;
+    ready: boolean;
+    mode: ConnectorMode;
+    serviceName: string;
+    ingestingHost?: string;
+    status: 'enabled' | 'missing';
+    errorTracking: {
+        enabled: boolean;
+        ready: boolean;
+        status: 'enabled' | 'missing';
+        dsn?: string;
+        tracesSampleRate: number;
+        environment?: string;
+        release?: string;
+    };
+    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;
+        context?: Record<string, unknown>;
+    }) => void;
+}
+export interface ResolvedSentryConnector {
+    enabled: boolean;
+    ready: boolean;
+    mode: ConnectorMode;
+    status: 'enabled' | 'missing';
+    send: (record: {
+        timestamp: string;
+        level: string;
+        message: string;
+        [key: string]: unknown;
+    }, options?: {
+        source?: 'server' | 'client';
+        warnIfUnavailable?: boolean;
+    }) => void;
+}
+export interface ResolvedOTLPConnector {
+    name: string;
+    enabled: boolean;
+    ready: boolean;
+    mode: ConnectorMode;
+    serviceName: string;
+    endpoint?: string;
+    status: 'enabled' | 'missing';
+    send: (record: {
+        timestamp: string;
+        level: string;
+        message: string;
+        [key: string]: unknown;
+    }, options?: {
+        source?: 'server' | 'client';
+        warnIfUnavailable?: boolean;
+    }) => void;
+}
+export interface ResolvedOTLPRegistry {
+    get: (name: string) => ResolvedOTLPConnector;
+    getAutoForwardTargets: () => ResolvedOTLPConnector[];
+    send: (name: string, record: {
+        timestamp: string;
+        level: string;
+        message: string;
+        [key: string]: unknown;
+    }, options?: {
+        source?: 'server' | 'client';
+        warnIfUnavailable?: boolean;
+    }) => void;
+    flush: () => Promise<void>;
+}
+export interface ResolvedServerLogger<Ctx> {
+    logger: BlypLogger;
+    betterstack: ResolvedBetterStackConnector;
+    posthog: ResolvedPostHogConnector;
+    sentry: ResolvedSentryConnector;
+    otlp: ResolvedOTLPRegistry;
+    resolvedConfig: BlypConfig;
+    level: string;
+    pretty: boolean;
+    logDir?: string;
+    file?: LogFileConfig;
+    autoLogging: ServerLoggerConfig<Ctx>['autoLogging'];
+    customProps?: (ctx: Ctx) => Record<string, unknown>;
+    logErrors: boolean;
+    resolvedIgnorePaths?: string[];
+    resolvedClientLogging: ClientLogIngestionConfig<Ctx> | null;
+    ingestionPath: string;
+}
+export type { HttpRequestLog } from './http';

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

@@ -0,0 +1,64 @@
+import type { BlypLogger } from '../core/logger';
+import type { BlypDestination, BlypConnectorsConfig, ClientLoggingConfig, DatabaseLoggerConfig, LogFileConfig, LogRotationConfig } from '../core/config';
+export type LogLevel = 'error' | 'critical' | 'warning' | 'info' | 'success' | 'debug' | 'table';
+export interface StandaloneLoggerConfig {
+    pretty?: boolean;
+    level?: string;
+    destination?: BlypDestination;
+    logDir?: string;
+    file?: LogFileConfig;
+    database?: DatabaseLoggerConfig;
+    clientLogging?: ClientLoggingConfig;
+    connectors?: BlypConnectorsConfig;
+}
+export interface StandaloneLogger extends BlypLogger {
+    success: (message: string | unknown, meta?: unknown) => void;
+    critical: (message: string | unknown, meta?: unknown) => void;
+    table: (message: string, data?: unknown) => void;
+    warn: (message: unknown, ...args: unknown[]) => void;
+    warning: (message: unknown, ...args: unknown[]) => void;
+}
+export type { BlypConnectorsConfig, BlypDestination, ClientLoggingConfig, DatabaseLoggerConfig, LogFileConfig, LogRotationConfig, };
+export type RuntimeType = 'bun' | 'node';
+export interface RuntimeAdapter {
+    readonly type: RuntimeType;
+    readonly isBun: boolean;
+    readonly isNode: boolean;
+    file: {
+        existsSync: (path: string) => boolean;
+        mkdirSync: (path: string, options?: {
+            recursive?: boolean;
+        }) => void;
+        writeFileSync: (path: string, data: string) => void;
+    };
+    path: {
+        join: (...paths: string[]) => string;
+    };
+    env: {
+        get: (key: string) => string | undefined;
+    };
+    cwd: () => string;
+}
+export interface LogLevels {
+    error: 0;
+    critical: 1;
+    warning: 2;
+    info: 3;
+    success: 4;
+    debug: 5;
+    table: 6;
+    [key: string]: number;
+}
+export interface ColorConfig {
+    error: string;
+    critical: string;
+    warning: string;
+    info: string;
+    success: string;
+    debug: string;
+    table: string;
+}
+export interface CallerLocation {
+    file: string;
+    line: number | null;
+}

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

@@ -0,0 +1,37 @@
+import type { BlypLogger } from '../../core/logger';
+import type { ClientLogIngestionConfig as SharedClientLogIngestionConfig, HttpRequestLog, ServerLoggerConfig } from './shared';
+export interface SvelteKitLocals {
+    blypLog?: BlypLogger;
+    [key: string]: unknown;
+}
+export interface SvelteKitRequestEvent {
+    request: Request;
+    url: URL;
+    params?: Record<string, string>;
+    route?: {
+        id?: string | null;
+    };
+    locals: SvelteKitLocals;
+    [key: string]: unknown;
+}
+export type SvelteKitResolve = (event: SvelteKitRequestEvent) => Response | Promise<Response>;
+export type SvelteKitHandle = (input: {
+    event: SvelteKitRequestEvent;
+    resolve: SvelteKitResolve;
+}) => Response | Promise<Response>;
+export type SvelteKitRequestHandler = (event: SvelteKitRequestEvent) => Response | Promise<Response>;
+export interface SvelteKitLoggerContext {
+    event: SvelteKitRequestEvent;
+    response?: Response;
+    error?: unknown;
+}
+export interface SvelteKitLoggerConfig extends ServerLoggerConfig<SvelteKitLoggerContext> {
+}
+export interface SvelteKitClientLogIngestionConfig extends SharedClientLogIngestionConfig<SvelteKitLoggerContext> {
+}
+export interface SvelteKitLoggerFactory {
+    logger: BlypLogger;
+    handle: SvelteKitHandle;
+    clientLogHandler: SvelteKitRequestHandler;
+}
+export type { HttpRequestLog };

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

@@ -0,0 +1,28 @@
+import type { BlypLogger } from '../../core/logger';
+import type { ClientLogIngestionConfig as SharedClientLogIngestionConfig, HttpRequestLog, ServerLoggerConfig } from './shared';
+export interface TanStackStartMiddlewareContext {
+    request: Request;
+    context: Record<string, unknown>;
+    next: (options?: {
+        context?: Record<string, unknown>;
+    }) => Promise<Response>;
+}
+export interface TanStackStartLoggerContext {
+    request: Request;
+    context: Record<string, unknown>;
+    response?: Response;
+    error?: unknown;
+}
+export interface TanStackStartLoggerConfig extends ServerLoggerConfig<TanStackStartLoggerContext> {
+}
+export interface TanStackStartClientLogIngestionConfig extends SharedClientLogIngestionConfig<TanStackStartLoggerContext> {
+}
+export interface TanStackStartClientLogHandlers {
+    POST: (request: Request) => Promise<Response>;
+}
+export interface TanStackStartLoggerFactory {
+    logger: BlypLogger;
+    requestMiddleware: (input: TanStackStartMiddlewareContext) => Promise<Response>;
+    clientLogHandlers: TanStackStartClientLogHandlers;
+}
+export type { HttpRequestLog };

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

@@ -0,0 +1,33 @@
+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>;
+}
+export interface WorkersLoggerState {
+    env?: Record<string, unknown>;
+    customProps?: (request: Request) => Record<string, unknown>;
+}
+export type WorkersConsoleMethod = 'debug' | 'info' | 'warn' | 'error' | 'log';
+export type WorkersLogLevel = 'debug' | 'info' | 'warn' | 'warning' | 'error' | 'success' | 'critical';
+export interface WorkersEmitOptions {
+    response?: Response | {
+        status: number;
+    };
+    status?: number;
+    error?: unknown;
+}
+export interface WorkersRequestLogger {
+    set(fields: Record<string, unknown>): WorkersRequestLogger;
+    emit(options?: WorkersEmitOptions): HttpRequestLog;
+    debug(message: unknown, ...args: unknown[]): void;
+    info(message: unknown, ...args: unknown[]): void;
+    warn(message: unknown, ...args: unknown[]): void;
+    warning(message: unknown, ...args: unknown[]): void;
+    error(message: unknown, ...args: unknown[]): void;
+    success(message: unknown, ...args: unknown[]): void;
+    critical(message: unknown, ...args: unknown[]): void;
+    table(message: string, data?: unknown): void;
+    createStructuredLog(groupId: string, initial?: Record<string, unknown>): StructuredLog;
+}
+export type { HttpRequestLog, StructuredLog };