@zudojs/observability 0.0.1 → 1.0.0

package/dist/observability/observability.core.js

@@ -7,11 +7,13 @@
  */
 import { LogLevel } from "../types.js";
 import { StructuredLogger } from "../logger/index.js";
-import { DefaultMetricsRegistry } from "../metrics/index.js";
+import { DefaultMetricsRegistry, PeriodicMetricReader, } from "../metrics/index.js";
 import { DefaultTracer } from "../tracing/index.js";
 import { AsyncPropagationManager } from "../propagation/index.js";
-import { ConsoleLogExporter, ConsoleSpanExporter, ConsoleMetricExporter, } from "../exporter/index.js";
-import { BatchSpanProcessor } from "../processor/index.js";
+import { ConsoleLogExporter, ConsoleSpanExporter, ConsoleMetricExporter, noopLogExporter, noopMetricExporter, } from "../exporter/index.js";
+import { BatchLogProcessor, BatchSpanProcessor, noopSpanExporter, } from "../processor/index.js";
+import { createRedactor, createStructureRedactor } from "../redaction/index.js";
+import { AlwaysOnSampler } from "../sampling/index.js";
 /**
  * Default observability implementation.
  *
@@ -23,66 +25,220 @@ export class DefaultObservability {
     metrics;
     tracer;
     propagation;
+    pipeline;
     resourceAttributes;
-    shutdownHooks = [];
-    constructor(config) {
-        this.resourceAttributes = {
-            "service.name": config.serviceName,
-            ...(config.serviceVersion
-                ? { "service.version": config.serviceVersion }
-                : {}),
-            ...(config.environment
-                ? { "deployment.environment": config.environment }
-                : {}),
-            ...(config.resource ?? {}),
-        };
-        // Logger — uses console by default, or the provided exporter
-        const logExporter = config.logExporter ?? new ConsoleLogExporter();
-        this.logger = new StructuredLogger({
-            name: config.serviceName,
-            level: config.logLevel ?? LogLevel.INFO,
-            transport: {
-                name: "observability",
-                write: (record) => {
-                    void logExporter.export([record]);
-                },
-            },
-        });
-        // Metrics
-        this.metrics = new DefaultMetricsRegistry();
-        // Tracing
-        const spanExporter = config.spanExporter ?? new ConsoleSpanExporter();
-        const processor = new BatchSpanProcessor({ exporter: spanExporter });
+    /** Scopes share the parent's pipeline, so only the root tears it down. */
+    ownsPipeline;
+    shutdownPromise;
+    constructor(config, scope) {
+        this.resourceAttributes =
+            scope?.resourceAttributes ?? buildResourceAttributes(config);
+        if (scope) {
+            this.pipeline = scope.pipeline;
+            this.ownsPipeline = false;
+        }
+        else {
+            this.pipeline = buildPipeline(config);
+            this.ownsPipeline = true;
+        }
+        this.logger = this.pipeline.logger;
+        this.metrics = this.pipeline.metrics;
+        this.propagation = this.pipeline.propagation;
+        // The tracer is the one piece that differs per scope, because the
+        // resource attributes it stamps onto spans are the scope.
         this.tracer = new DefaultTracer({
-            processors: config.processors ?? [processor],
-            exporter: spanExporter,
+            processors: this.pipeline.processors,
             resource: this.resourceAttributes,
-        });
-        // Propagation
-        this.propagation = new AsyncPropagationManager();
-        // Register shutdown hooks
-        this.shutdownHooks.push(async () => {
-            await processor.shutdown();
-            await spanExporter.shutdown();
-            await logExporter.shutdown();
+            sampler: this.pipeline.sampler ?? new AlwaysOnSampler(),
+            limits: this.pipeline.config.spanLimits,
+            captureStackTraces: this.pipeline.config.captureStackTraces,
+            redactAttribute: this.pipeline.redactAttribute,
+            onError: this.pipeline.config.onError,
         });
     }
+    /**
+     * Creates a scope that differs only in its resource attributes.
+     *
+     * The logger, registry, processors and exporters are shared with the parent:
+     * building a second pipeline here silently dropped every configured
+     * exporter and log level, and left an orphan flush timer nobody shut down.
+     */
     resource(attributes) {
-        const child = new DefaultObservability({
-            serviceName: this.resourceAttributes["service.name"] ?? "unknown",
-            resource: { ...this.resourceAttributes, ...attributes },
+        return new DefaultObservability(this.pipeline.config, {
+            pipeline: this.pipeline,
+            resourceAttributes: { ...this.resourceAttributes, ...attributes },
         });
-        return child;
     }
+    /**
+     * Drains every buffer without shutting anything down.
+     *
+     * A scope shares its parent's pipeline, so draining from one is both safe
+     * and what the caller asked for. Returning early because the scope does not
+     * *own* the pipeline made `obs.resource({...}).flush()` a silent no-op —
+     * the buffered records it was meant to push were still sitting in the queue
+     * when the caller went on to exit.
+     */
+    async flush() {
+        await this.drain();
+    }
+    async drain() {
+        const tasks = [];
+        if (this.pipeline.logProcessor) {
+            tasks.push(this.pipeline.logProcessor.flush());
+        }
+        for (const processor of this.pipeline.processors) {
+            if (processor.forceFlush)
+                tasks.push(processor.forceFlush());
+        }
+        tasks.push(this.pipeline.metricReader.collect());
+        await this.reportFailures(await Promise.allSettled(tasks), "flush");
+    }
+    async reportFailures(results, source) {
+        for (const result of results) {
+            if (result.status === "rejected") {
+                this.pipeline.config.onError?.(result.reason, source);
+            }
+        }
+    }
+    /**
+     * Shuts the pipeline down. Idempotent, and one failing step never skips the
+     * rest — a half-torn-down telemetry stack is worse than a noisy one.
+     *
+     * A scope created by {@link DefaultObservability.resource} does not own the
+     * pipeline and shutting it down is a no-op; shut down the root instead.
+     */
     async shutdown() {
-        for (const hook of this.shutdownHooks) {
-            await hook();
+        if (!this.ownsPipeline)
+            return;
+        this.shutdownPromise ??= this.performShutdown();
+        return this.shutdownPromise;
+    }
+    async performShutdown() {
+        // Drain first: whatever is still queued should reach the backend before
+        // the exporters close.
+        await this.drain();
+        const steps = [];
+        steps.push(this.pipeline.metricReader.shutdown());
+        if (this.pipeline.logProcessor) {
+            steps.push(this.pipeline.logProcessor.shutdown());
         }
-        if (this.tracer instanceof DefaultTracer) {
-            await this.tracer.shutdown();
+        for (const processor of this.pipeline.processors) {
+            steps.push(processor.shutdown());
         }
+        // Every exporter this facade created is owned by exactly one processor or
+        // reader, which closes it in the step above; an exporter supplied by the
+        // caller is therefore never closed twice.
+        await this.reportFailures(await Promise.allSettled(steps), "shutdown");
     }
 }
+function buildResourceAttributes(config) {
+    return {
+        "service.name": config.serviceName,
+        ...(config.serviceVersion
+            ? { "service.version": config.serviceVersion }
+            : {}),
+        ...(config.environment
+            ? { "deployment.environment": config.environment }
+            : {}),
+        ...(config.resource ?? {}),
+    };
+}
+function buildPipeline(config) {
+    const useConsole = config.useConsoleExporters ?? true;
+    /* ── Logging ─────────────────────────────────────────────────────────── */
+    const logExporter = config.logExporter ??
+        (useConsole ? new ConsoleLogExporter() : noopLogExporter);
+    const logProcessor = new BatchLogProcessor({
+        exporter: logExporter,
+        batchSize: config.logBatchSize,
+        flushIntervalMs: config.logFlushIntervalMs,
+        onError: config.onError,
+        onDrop: (dropped) => config.onError?.(new Error(`Dropped ${dropped} log records: queue full`), "BatchLogProcessor"),
+    });
+    // Redaction is applied by the logger, so every transport and exporter
+    // downstream sees redacted records — configuring it and not wiring it here
+    // is what made the "credentials are never logged" promise untrue.
+    const redactor = config.redaction
+        ? createStructureRedactor(config.redaction)
+        : undefined;
+    const logger = new StructuredLogger({
+        name: config.serviceName,
+        level: config.logLevel ?? LogLevel.INFO,
+        transport: logProcessor,
+        redact: redactor
+            ? (context) => redactor(context)
+            : undefined,
+    });
+    /* ── Tracing ─────────────────────────────────────────────────────────── */
+    // Built only when this facade owns the processor: constructing an exporter
+    // the caller's own processors will never touch is waste at best and a
+    // second, unclosed handle at worst.
+    const ownSpanExporter = () => config.spanExporter ??
+        (useConsole ? new ConsoleSpanExporter() : noopSpanExporter);
+    const processors = config.processors ?? [
+        new BatchSpanProcessor({
+            exporter: ownSpanExporter(),
+            onError: config.onError,
+            onDrop: (dropped) => config.onError?.(new Error(`Dropped ${dropped} spans: queue full`), "BatchSpanProcessor"),
+        }),
+    ];
+    // When the caller supplied their own processors, they own the exporter's
+    // lifecycle too; otherwise our processor closes it on shutdown.
+    /* ── Metrics ─────────────────────────────────────────────────────────── */
+    const metrics = new DefaultMetricsRegistry({
+        ...(config.metrics ?? {}),
+        onCardinalityLimit: (name, size) => {
+            config.metrics?.onCardinalityLimit?.(name, size);
+            config.onError?.(new Error(`Metric "${name}" exceeded the registry's series limit (${size}); ` +
+                `check for a high-cardinality label`), "MetricsRegistry");
+        },
+    });
+    const metricExporter = config.metricExporter ??
+        (useConsole ? new ConsoleMetricExporter() : undefined);
+    // The reader is built whenever there is anything to export to, even at
+    // interval 0. `start()` is a no-op at 0, so periodic export stays disabled
+    // as documented — but `flush()` and `shutdown()` still collect a final
+    // snapshot and close the exporter. Skipping the reader entirely left a
+    // console exporter this facade had constructed running to the end of the
+    // process with no metric ever leaving it.
+    const metricIntervalMs = config.metricExportIntervalMs ?? 60_000;
+    const metricReader = new PeriodicMetricReader({
+        registry: metrics,
+        exporter: metricExporter ?? noopMetricExporter,
+        intervalMs: metricIntervalMs,
+        onError: config.onError,
+    });
+    metricReader.start();
+    const redactAttribute = config.redaction
+        ? buildAttributeRedactor(config.redaction)
+        : undefined;
+    return {
+        logger,
+        metrics,
+        propagation: new AsyncPropagationManager(),
+        processors,
+        logProcessor,
+        metricReader,
+        config,
+        sampler: config.sampler,
+        redactAttribute,
+    };
+}
+/**
+ * Builds the span-attribute redactor.
+ *
+ * A sensitive key replaces its whole value; anything else is still walked, so
+ * a token nested inside an otherwise innocuous `request` attribute is caught
+ * too.
+ */
+function buildAttributeRedactor(redaction) {
+    const leaf = createRedactor(redaction);
+    const deep = createStructureRedactor(redaction);
+    return (key, value) => {
+        const replaced = leaf(key, value);
+        return replaced === value ? deep(value) : replaced;
+    };
+}
 /** Creates an observability instance. */
 export function createObservability(config) {
     return new DefaultObservability(config);

package/dist/processor/index.d.ts

@@ -1,7 +1,8 @@
 /**
- * @zudojs/observability — Processor
+ * @zudojs/observability — Processors
  *
- * Batch span processor for accumulating and exporting spans.
+ * Batching and simple processors for spans, and a batching log transport.
  */
-export { BatchSpanProcessor, createBatchSpanProcessor, } from "./processor.batch.js";
+export { BatchSpanProcessor, createBatchSpanProcessor, SimpleSpanProcessor, createSimpleSpanProcessor, noopSpanExporter, type BatchSpanProcessorOptions, } from "./processor.batch.js";
+export { BatchLogProcessor, createBatchLogProcessor, type BatchLogProcessorOptions, } from "./processor.log.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/processor/index.js

@@ -1,7 +1,8 @@
 /**
- * @zudojs/observability — Processor
+ * @zudojs/observability — Processors
  *
- * Batch span processor for accumulating and exporting spans.
+ * Batching and simple processors for spans, and a batching log transport.
  */
-export { BatchSpanProcessor, createBatchSpanProcessor, } from "./processor.batch.js";
+export { BatchSpanProcessor, createBatchSpanProcessor, SimpleSpanProcessor, createSimpleSpanProcessor, noopSpanExporter, } from "./processor.batch.js";
+export { BatchLogProcessor, createBatchLogProcessor, } from "./processor.log.js";
 //# sourceMappingURL=index.js.map

package/dist/processor/processor.batch.d.ts

@@ -2,9 +2,27 @@
  * @zudojs/observability — Processor
  *
  * Batch span processor that accumulates spans and exports them periodically.
- * Memory-bounded with configurable batch size and flush interval.
+ * Genuinely memory-bounded: the queue has a hard cap, and spans past it are
+ * dropped and counted rather than growing the process until it dies.
  */
 import type { ReadableSpan, Span, SpanExporter, SpanProcessor } from "../types.js";
+/** A span exporter that discards everything, for tests and disabled tracing. */
+export declare const noopSpanExporter: SpanExporter;
+/** Options for {@link BatchSpanProcessor}. */
+export interface BatchSpanProcessorOptions {
+    /** Where completed spans go. Required — a processor with no exporter is a leak with extra steps. */
+    readonly exporter: SpanExporter;
+    /** Spans per export call. Default: 512. */
+    readonly batchSize?: number;
+    /** How often the queue is drained, in ms. Default: 5,000. */
+    readonly flushIntervalMs?: number;
+    /** Hard cap on queued spans. Default: 2,048. */
+    readonly maxQueueSize?: number;
+    /** Reports export failures and dropped spans. */
+    readonly onError?: (error: unknown, source: string) => void;
+    /** Called when spans are dropped because the queue was full. */
+    readonly onDrop?: (droppedCount: number) => void;
+}
 /**
  * Collects completed spans and exports them in batches.
  * Flushes on batch size or interval, whichever comes first.
@@ -13,23 +31,60 @@ export declare class BatchSpanProcessor implements SpanProcessor {
     private readonly exporter;
     private readonly batchSize;
     private readonly flushIntervalMs;
+    private readonly maxQueueSize;
+    private readonly onError?;
+    private readonly onDrop?;
     private buffer;
     private timer?;
     private shuttingDown;
-    constructor(options?: {
-        readonly exporter?: SpanExporter;
-        readonly batchSize?: number;
-        readonly flushIntervalMs?: number;
-    });
+    private inFlight?;
+    private droppedSpans;
+    constructor(options: BatchSpanProcessorOptions);
     onStart(_span: Span): void;
     onEnd(span: ReadableSpan): void;
+    private startTimer;
+    private stopTimer;
+    /** Number of spans dropped because the queue was full. */
+    getDroppedCount(): number;
+    /** Spans currently queued. */
+    getQueueSize(): number;
+    /**
+     * Exports everything queued.
+     *
+     * Concurrent calls are serialised: two overlapping exports against the same
+     * backend is a good way to double-deliver a batch or exhaust a connection
+     * pool.
+     */
     flush(): Promise<void>;
+    private drain;
+    /** Drains the queue without shutting the processor down. */
+    forceFlush(): Promise<void>;
     shutdown(): Promise<void>;
 }
 /** Creates a batch span processor. */
-export declare function createBatchSpanProcessor(options?: {
-    readonly exporter?: SpanExporter;
-    readonly batchSize?: number;
-    readonly flushIntervalMs?: number;
-}): BatchSpanProcessor;
+export declare function createBatchSpanProcessor(options: BatchSpanProcessorOptions): BatchSpanProcessor;
+/**
+ * A processor that exports each span as it ends.
+ *
+ * Simple and immediate; use it in tests and short-lived processes, and the
+ * batch processor everywhere else.
+ */
+export declare class SimpleSpanProcessor implements SpanProcessor {
+    private readonly exporter;
+    private readonly onError?;
+    private pending;
+    constructor(options: {
+        readonly exporter: SpanExporter;
+        readonly onError?: (error: unknown, source: string) => void;
+    });
+    onStart(_span: Span): void;
+    onEnd(span: ReadableSpan): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+/** Creates a simple, unbatched span processor. */
+export declare function createSimpleSpanProcessor(options: {
+    readonly exporter: SpanExporter;
+    readonly onError?: (error: unknown, source: string) => void;
+}): SimpleSpanProcessor;
 //# sourceMappingURL=processor.batch.d.ts.map

package/dist/processor/processor.batch.js

@@ -2,10 +2,17 @@
  * @zudojs/observability — Processor
  *
  * Batch span processor that accumulates spans and exports them periodically.
- * Memory-bounded with configurable batch size and flush interval.
+ * Genuinely memory-bounded: the queue has a hard cap, and spans past it are
+ * dropped and counted rather than growing the process until it dies.
  */
 const DEFAULT_BATCH_SIZE = 512;
 const DEFAULT_FLUSH_INTERVAL_MS = 5_000;
+const DEFAULT_MAX_QUEUE_SIZE = 2_048;
+/** A span exporter that discards everything, for tests and disabled tracing. */
+export const noopSpanExporter = {
+    export: async () => { },
+    shutdown: async () => { },
+};
 /**
  * Collects completed spans and exports them in batches.
  * Flushes on batch size or interval, whichever comes first.
@@ -14,64 +21,158 @@ export class BatchSpanProcessor {
     exporter;
     batchSize;
     flushIntervalMs;
+    maxQueueSize;
+    onError;
+    onDrop;
     buffer = [];
     timer;
     shuttingDown = false;
+    inFlight;
+    droppedSpans = 0;
     constructor(options) {
-        this.exporter = options?.exporter ?? {
-            export: async () => { },
-            shutdown: async () => { },
-        };
-        this.batchSize = options?.batchSize ?? DEFAULT_BATCH_SIZE;
-        this.flushIntervalMs =
-            options?.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
+        this.exporter = options.exporter;
+        this.batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
+        this.flushIntervalMs = options.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
+        this.maxQueueSize = Math.max(options.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE, this.batchSize);
+        this.onError = options.onError;
+        this.onDrop = options.onDrop;
     }
     onStart(_span) {
-        // No-op: we only care about completed spans
+        // No-op: we only care about completed spans.
     }
     onEnd(span) {
         if (this.shuttingDown)
             return;
+        if (this.buffer.length >= this.maxQueueSize) {
+            this.droppedSpans++;
+            this.onDrop?.(this.droppedSpans);
+            return;
+        }
         this.buffer.push(span);
         if (this.buffer.length >= this.batchSize) {
             void this.flush();
             return;
         }
-        if (!this.timer) {
-            this.timer = setInterval(() => {
-                void this.flush();
-            }, this.flushIntervalMs);
-            // Allow the process to exit even if the timer is active
-            if (this.timer &&
-                typeof this.timer === "object" &&
-                "unref" in this.timer) {
-                this.timer.unref();
+        this.startTimer();
+    }
+    startTimer() {
+        if (this.timer !== undefined || this.shuttingDown)
+            return;
+        this.timer = setInterval(() => {
+            if (this.buffer.length === 0) {
+                // Nothing left to drain: stop waking the event loop until the next
+                // span arrives, rather than ticking forever for the process lifetime.
+                this.stopTimer();
+                return;
             }
+            void this.flush();
+        }, this.flushIntervalMs);
+        // Allow the process to exit even if the timer is active.
+        if (typeof this.timer === "object" && "unref" in this.timer) {
+            this.timer.unref();
+        }
+    }
+    stopTimer() {
+        if (this.timer !== undefined) {
+            clearInterval(this.timer);
+            this.timer = undefined;
         }
     }
+    /** Number of spans dropped because the queue was full. */
+    getDroppedCount() {
+        return this.droppedSpans;
+    }
+    /** Spans currently queued. */
+    getQueueSize() {
+        return this.buffer.length;
+    }
+    /**
+     * Exports everything queued.
+     *
+     * Concurrent calls are serialised: two overlapping exports against the same
+     * backend is a good way to double-deliver a batch or exhaust a connection
+     * pool.
+     */
     async flush() {
-        if (this.buffer.length === 0)
-            return;
-        const batch = [...this.buffer];
-        this.buffer = [];
+        if (this.inFlight) {
+            await this.inFlight;
+            if (this.buffer.length === 0)
+                return;
+        }
+        const run = this.drain();
+        this.inFlight = run;
         try {
-            await this.exporter.export(batch);
+            await run;
         }
-        catch {
-            // Telemetry failure should not bring down the application
+        finally {
+            if (this.inFlight === run)
+                this.inFlight = undefined;
         }
     }
+    async drain() {
+        while (this.buffer.length > 0) {
+            const batch = this.buffer.splice(0, this.batchSize);
+            try {
+                await this.exporter.export(batch);
+            }
+            catch (error) {
+                // Telemetry failure must not bring down the application — but it must
+                // not be invisible either.
+                this.onError?.(error, "SpanExporter.export");
+            }
+        }
+    }
+    /** Drains the queue without shutting the processor down. */
+    async forceFlush() {
+        await this.flush();
+    }
     async shutdown() {
         this.shuttingDown = true;
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = undefined;
-        }
+        this.stopTimer();
         await this.flush();
+        await this.exporter.shutdown();
     }
 }
 /** Creates a batch span processor. */
 export function createBatchSpanProcessor(options) {
     return new BatchSpanProcessor(options);
 }
+/**
+ * A processor that exports each span as it ends.
+ *
+ * Simple and immediate; use it in tests and short-lived processes, and the
+ * batch processor everywhere else.
+ */
+export class SimpleSpanProcessor {
+    exporter;
+    onError;
+    pending = new Set();
+    constructor(options) {
+        this.exporter = options.exporter;
+        this.onError = options.onError;
+    }
+    onStart(_span) { }
+    onEnd(span) {
+        const task = this.exporter
+            .export([span])
+            .catch((error) => {
+            this.onError?.(error, "SpanExporter.export");
+        })
+            .finally(() => {
+            this.pending.delete(task);
+        });
+        this.pending.add(task);
+    }
+    async forceFlush() {
+        await Promise.allSettled([...this.pending]);
+    }
+    async shutdown() {
+        await this.forceFlush();
+        await this.exporter.shutdown();
+    }
+}
+/** Creates a simple, unbatched span processor. */
+export function createSimpleSpanProcessor(options) {
+    return new SimpleSpanProcessor(options);
+}
 //# sourceMappingURL=processor.batch.js.map

package/dist/processor/processor.log.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @zudojs/observability — Log Processor
+ *
+ * Buffers log records and hands them to an exporter in batches.
+ *
+ * A logger writes synchronously and cannot await anything, so the naive
+ * bridge — `void exporter.export([record])` — exports one record per line and
+ * turns any exporter rejection into an unhandled rejection, which ends the
+ * process under Node's default. This transport is that bridge done properly:
+ * bounded queue, batched export, errors reported, and a `flush()` that
+ * shutdown can await so the last records are not lost.
+ */
+import type { LogExporter, LogRecord, LogTransport } from "../types.js";
+/** Options for {@link BatchLogProcessor}. */
+export interface BatchLogProcessorOptions {
+    readonly exporter: LogExporter;
+    /** Records per export call. Default: 256. */
+    readonly batchSize?: number;
+    /** How often the queue is drained, in ms. Default: 1,000. */
+    readonly flushIntervalMs?: number;
+    /** Hard cap on queued records. Default: 4,096. */
+    readonly maxQueueSize?: number;
+    /** Reports export failures. */
+    readonly onError?: (error: unknown, source: string) => void;
+    /** Called when records are dropped because the queue was full. */
+    readonly onDrop?: (droppedCount: number) => void;
+}
+/** A {@link LogTransport} that batches records into a {@link LogExporter}. */
+export declare class BatchLogProcessor implements LogTransport {
+    readonly name = "batch";
+    private readonly exporter;
+    private readonly batchSize;
+    private readonly flushIntervalMs;
+    private readonly maxQueueSize;
+    private readonly onError?;
+    private readonly onDrop?;
+    private buffer;
+    private timer?;
+    private shuttingDown;
+    private inFlight?;
+    private droppedRecords;
+    constructor(options: BatchLogProcessorOptions);
+    write(record: LogRecord): void;
+    private startTimer;
+    private stopTimer;
+    /** Records dropped because the queue was full. */
+    getDroppedCount(): number;
+    /** Records currently queued. */
+    getQueueSize(): number;
+    flush(): Promise<void>;
+    private drain;
+    shutdown(): Promise<void>;
+}
+/** Creates a batching log transport. */
+export declare function createBatchLogProcessor(options: BatchLogProcessorOptions): BatchLogProcessor;
+//# sourceMappingURL=processor.log.d.ts.map