@blyp/core 0.1.21 → 0.1.23

package/dist/connectors/delivery/backoff.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedConnectorRetryConfig } from '../../types/core/config';
+export declare function computeConnectorRetryDelay(attempt: number, config: ResolvedConnectorRetryConfig): number;

package/dist/connectors/delivery/manager.d.ts

@@ -0,0 +1,44 @@
+import type { LogRecord } from '../../core/file-logger';
+import type { ResolvedConnectorDeliveryConfig } from '../../types/core/config';
+import { type ConnectorBatchDispatcher, type ConnectorBatchDispatchTarget, type ConnectorDeliveryStatusRecord, type ConnectorDeliveryBinder, type DurableConnectorDeadLetterRecord, type QueuedConnectorType } from './types';
+export declare class ConnectorDeliveryManager implements ConnectorDeliveryBinder {
+    private readonly config;
+    private readonly warnOnce;
+    private readonly memoryQueue;
+    private readonly durableStaging;
+    private readonly dispatchers;
+    private activeDispatches;
+    private flushPromise;
+    private durableFlushPromise;
+    private pollTimer;
+    private durablePollRunning;
+    private closed;
+    private durableClient;
+    private durableReady;
+    private durableInitPromise;
+    constructor(config: ResolvedConnectorDeliveryConfig);
+    bindTarget(target: ConnectorBatchDispatchTarget): void;
+    unbindTarget(target: ConnectorBatchDispatchTarget): void;
+    enqueue(connectorType: QueuedConnectorType, record: LogRecord, dispatcher: ConnectorBatchDispatcher, target?: string): void;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+    getDurableCountForTests(): Promise<number>;
+    getStatusSummaryForTests(): Promise<ConnectorDeliveryStatusRecord[]>;
+    listDeadLettersForTests(): Promise<DurableConnectorDeadLetterRecord[]>;
+    private initializeDurableQueue;
+    private scheduleDispatch;
+    private pumpMemoryQueue;
+    private takeNextMemoryBatch;
+    private dispatchMemoryBatch;
+    private handleRetryableFailure;
+    private recordSuccessfulDispatch;
+    private recordFailedDispatch;
+    private stageDurableJob;
+    private flushDurableStaging;
+    private processDurableQueueOnce;
+    private drainDurableQueueForFlush;
+    private scheduleDurablePoll;
+    private enforceMemoryCapacity;
+    private hasReadyMemoryJobs;
+    private processUntilIdle;
+}

package/dist/connectors/delivery/queue-path.d.ts

@@ -0,0 +1 @@
+export declare function getDefaultConnectorQueuePath(): string;

package/dist/connectors/delivery/sqlite-adapter-bun.d.ts

@@ -0,0 +1 @@
+export declare const BUN_SQLITE_MODULE = "bun:sqlite";

package/dist/connectors/delivery/sqlite-adapter-node.d.ts

@@ -0,0 +1 @@
+export declare const NODE_SQLITE_MODULE = "node:sqlite";

package/dist/connectors/delivery/sqlite-client.d.ts

@@ -0,0 +1,37 @@
+import type { ConnectorDeliveryStatusRecord, DeadLetterListResult, DurableConnectorDeadLetterRecord, DurableConnectorJobRecord, DurableQueueRescheduleInput } from './types';
+export declare class SQLiteWorkerClient {
+    private readonly path;
+    private readonly worker;
+    private readonly pending;
+    private nextId;
+    constructor(path: string);
+    private request;
+    init(): Promise<void>;
+    insert(jobs: DurableConnectorJobRecord[]): Promise<void>;
+    claimDue(limit: number, now: number): Promise<DurableConnectorJobRecord[]>;
+    ack(ids: string[]): Promise<void>;
+    reschedule(items: DurableQueueRescheduleInput[], now: number): Promise<void>;
+    deadLetter(items: DurableConnectorDeadLetterRecord[]): Promise<void>;
+    markSuccess(items: Array<{
+        connectorType: string;
+        connectorTarget?: string;
+        timestamp: number;
+    }>): Promise<void>;
+    markFailure(items: Array<{
+        connectorType: string;
+        connectorTarget?: string;
+        timestamp: number;
+        lastError?: string;
+    }>): Promise<void>;
+    getStatusSummary(): Promise<ConnectorDeliveryStatusRecord[]>;
+    listDeadLetters(input: {
+        limit: number;
+        offset: number;
+        connectorType?: string;
+        connectorTarget?: string;
+    }): Promise<DeadLetterListResult>;
+    retryDeadLetters(ids: string[], now: number): Promise<number>;
+    clearDeadLetters(ids: string[]): Promise<number>;
+    count(): Promise<number>;
+    shutdown(): Promise<void>;
+}

package/dist/connectors/delivery/sqlite-worker.d.ts

@@ -0,0 +1 @@
+export declare function buildSQLiteWorkerSource(): string;

package/dist/connectors/delivery/studio-queue.d.ts

@@ -0,0 +1,12 @@
+import type { ConnectorDeliveryStatusRecord, DeadLetterListResult } from './types';
+export declare function getConnectorQueuePath(): string;
+export declare function connectorQueueExists(queuePath?: string): boolean;
+export declare function getConnectorDeliveryStatusSummary(queuePath?: string): Promise<ConnectorDeliveryStatusRecord[]>;
+export declare function listConnectorDeadLetters(input?: {
+    limit?: number;
+    offset?: number;
+    connectorType?: string;
+    connectorTarget?: string;
+}, queuePath?: string): Promise<DeadLetterListResult>;
+export declare function retryConnectorDeadLetters(ids: string[], queuePath?: string): Promise<number>;
+export declare function clearConnectorDeadLetters(ids: string[], queuePath?: string): Promise<number>;

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

@@ -0,0 +1,98 @@
+import type { LogRecord } from '../../core/file-logger';
+export declare const CONNECTOR_BATCH_DISPATCH: unique symbol;
+export declare const CONNECTOR_DELIVERY_BINDER: unique symbol;
+export type QueuedConnectorType = 'betterstack' | 'databuddy' | 'posthog' | 'sentry' | 'otlp';
+export interface ConnectorDispatchContext {
+    source: 'server';
+    target?: string;
+}
+export interface ConnectorDispatchSuccess {
+    ok: true;
+}
+export interface ConnectorDispatchFailure {
+    ok: false;
+    retryable: boolean;
+    status?: number;
+    error?: string;
+}
+export type ConnectorDispatchResult = ConnectorDispatchSuccess | ConnectorDispatchFailure;
+export interface ConnectorBatchDispatcher {
+    dispatchKey: string;
+    dispatch(records: LogRecord[], context: ConnectorDispatchContext): Promise<ConnectorDispatchResult>;
+}
+export interface ConnectorDeliveryJob {
+    id: string;
+    connectorType: QueuedConnectorType;
+    connectorTarget?: string;
+    source: 'server';
+    record: LogRecord;
+    attemptCount: number;
+    maxAttempts: number;
+    nextAttemptAt: number;
+    createdAt: number;
+    dispatchKey: string;
+    dispatcher: ConnectorBatchDispatcher;
+}
+export interface SerializedConnectorJobEnvelope {
+    jobId: string;
+    connectorType: QueuedConnectorType;
+    connectorTarget?: string;
+    source: 'server';
+    record: LogRecord;
+    createdAt: number;
+}
+export interface DurableConnectorJobRecord {
+    id: string;
+    connectorType: QueuedConnectorType;
+    connectorTarget?: string;
+    operation: 'send';
+    payloadJson: string;
+    attemptCount: number;
+    maxAttempts: number;
+    nextAttemptAt: number;
+    state: 'pending' | 'claimed';
+    lastError?: string;
+    createdAt: number;
+    updatedAt: number;
+    claimedAt?: number;
+}
+export interface DurableQueueRescheduleInput {
+    id: string;
+    attemptCount: number;
+    nextAttemptAt: number;
+    lastError?: string;
+}
+export interface DurableConnectorDeadLetterRecord {
+    id: string;
+    connectorType: QueuedConnectorType;
+    connectorTarget?: string;
+    operation: 'send';
+    payloadJson: string;
+    attemptCount: number;
+    maxAttempts: number;
+    lastError?: string;
+    firstEnqueuedAt: number;
+    deadLetteredAt: number;
+    lastAttemptAt: number;
+}
+export interface ConnectorDeliveryStatusRecord {
+    connectorType: QueuedConnectorType;
+    connectorTarget?: string;
+    pendingCount: number;
+    deadLetterCount: number;
+    lastSuccessAt?: number;
+    lastFailureAt?: number;
+    lastError?: string;
+    updatedAt?: number;
+}
+export interface DeadLetterListResult {
+    items: DurableConnectorDeadLetterRecord[];
+    total: number;
+}
+export interface ConnectorDeliveryBinder {
+    enqueue(connectorType: QueuedConnectorType, record: LogRecord, dispatcher: ConnectorBatchDispatcher, target?: string): void;
+}
+export type ConnectorBatchDispatchTarget = {
+    [CONNECTOR_BATCH_DISPATCH]?: ConnectorBatchDispatcher;
+    [CONNECTOR_DELIVERY_BINDER]?: (binder: ConnectorDeliveryBinder | null) => void;
+};

package/dist/connectors/otlp/index.d.ts

@@ -1,5 +1,6 @@
 import { type StructuredLog } from '../../core/structured-log';
 import type { OTLPLogger, OTLPLoggerConfig } from '../../types/connectors/otlp';
 export type { OTLPLogger, OTLPLoggerConfig, } from '../../types/connectors/otlp';
+export { normalizeOTLPRecord } from './sender';
 export declare function createOtlpLogger(config?: OTLPLoggerConfig): OTLPLogger;
 export declare function createStructuredOtlpLogger<TFields extends Record<string, unknown> = Record<string, unknown>>(groupId: string, initial?: TFields, config?: OTLPLoggerConfig): StructuredLog<TFields>;