@zudojs/observability 0.1.0 → 1.0.0

package/dist/sampling/sampler.type.d.ts

@@ -12,18 +12,50 @@ export declare class AlwaysOnSampler implements Sampler {
 export declare class AlwaysOffSampler implements Sampler {
     shouldSample(): SamplingResult;
 }
-/** Samples a percentage of traces. */
+/**
+ * Samples a fixed fraction of traces.
+ *
+ * The decision is derived from the trace ID, so every service handling the
+ * same trace reaches the same answer and a trace is never sampled in half.
+ * The low 8 hex digits are used, matching the OpenTelemetry convention of
+ * taking the *trailing* bytes — the leading ones are the least varied in
+ * some ID schemes.
+ *
+ * When no usable trace ID is available the sampler falls back to a random
+ * draw at the same rate, rather than failing open in one direction and
+ * closed in another.
+ */
 export declare class ProbabilitySampler implements Sampler {
-    private readonly probability;
+    readonly probability: number;
     constructor(probability: number);
     shouldSample(_parentContext?: SpanContext, traceId?: string): SamplingResult;
 }
-/** Delegates to parent context's sampling decision, falls back to a root sampler. */
+/** Options for {@link ParentBasedSampler}. */
+export interface ParentBasedSamplerOptions {
+    /** Sampler consulted when there is no parent. Default: always on. */
+    readonly root?: Sampler;
+    /** Decision when the parent was sampled. Default: sample. */
+    readonly remoteParentSampled?: Sampler;
+    /** Decision when the parent was not sampled. Default: do not record. */
+    readonly remoteParentNotSampled?: Sampler;
+}
+/**
+ * Delegates to the parent's sampling decision, falling back to a root sampler.
+ *
+ * The parent's decision travels in `SpanContext.traceFlags`, which the tracer
+ * stamps on every span context it creates and every child inherits.
+ */
 export declare class ParentBasedSampler implements Sampler {
-    private readonly rootSampler;
-    constructor(rootSampler?: Sampler);
+    private readonly root;
+    private readonly parentSampled;
+    private readonly parentNotSampled;
+    constructor(rootOrOptions?: Sampler | ParentBasedSamplerOptions);
     shouldSample(parentContext?: SpanContext, traceId?: string): SamplingResult;
 }
+/** True when a sampling decision means the span should be exported. */
+export declare function isSampled(result: SamplingResult): boolean;
+/** True when a sampling decision means the span should be built at all. */
+export declare function isRecording(result: SamplingResult): boolean;
 /** Creates an always-on sampler. */
 export declare function createAlwaysOnSampler(): AlwaysOnSampler;
 /** Creates an always-off sampler. */
@@ -31,5 +63,5 @@ export declare function createAlwaysOffSampler(): AlwaysOffSampler;
 /** Creates a probability sampler. */
 export declare function createProbabilitySampler(probability: number): ProbabilitySampler;
 /** Creates a parent-based sampler. */
-export declare function createParentBasedSampler(rootSampler?: Sampler): ParentBasedSampler;
+export declare function createParentBasedSampler(rootOrOptions?: Sampler | ParentBasedSamplerOptions): ParentBasedSampler;
 //# sourceMappingURL=sampler.type.d.ts.map

package/dist/sampling/sampler.type.js

@@ -3,52 +3,93 @@
  *
  * Sampling strategies for controlling trace overhead.
  */
+import { TraceFlags } from "../types.js";
+import { generateHexId, isValidTraceId } from "../internal/index.js";
+import { ObservabilityConfigError } from "../errors/index.js";
+const RECORD_AND_SAMPLE = { decision: "RECORD_AND_SAMPLE" };
+const DO_NOT_RECORD = { decision: "DO_NOT_RECORD" };
 /** Always records and samples. */
 export class AlwaysOnSampler {
     shouldSample() {
-        return { decision: "RECORD_AND_SAMPLE" };
+        return RECORD_AND_SAMPLE;
     }
 }
 /** Never records or samples. */
 export class AlwaysOffSampler {
     shouldSample() {
-        return { decision: "DO_NOT_RECORD" };
+        return DO_NOT_RECORD;
     }
 }
-/** Samples a percentage of traces. */
+/**
+ * Samples a fixed fraction of traces.
+ *
+ * The decision is derived from the trace ID, so every service handling the
+ * same trace reaches the same answer and a trace is never sampled in half.
+ * The low 8 hex digits are used, matching the OpenTelemetry convention of
+ * taking the *trailing* bytes — the leading ones are the least varied in
+ * some ID schemes.
+ *
+ * When no usable trace ID is available the sampler falls back to a random
+ * draw at the same rate, rather than failing open in one direction and
+ * closed in another.
+ */
 export class ProbabilitySampler {
     probability;
     constructor(probability) {
+        if (!Number.isFinite(probability)) {
+            throw new ObservabilityConfigError(`Sampling probability must be a finite number; received ${probability}`, { probability });
+        }
         this.probability = Math.max(0, Math.min(1, probability));
     }
     shouldSample(_parentContext, traceId) {
-        if (!traceId)
-            return { decision: "RECORD_AND_SAMPLE" };
-        // Use the first 8 hex chars as a number for deterministic sampling
-        const sample = parseInt(traceId.slice(0, 8), 16) / 0xffffffff;
-        return sample < this.probability
-            ? { decision: "RECORD_AND_SAMPLE" }
-            : { decision: "DO_NOT_RECORD" };
+        if (this.probability >= 1)
+            return RECORD_AND_SAMPLE;
+        if (this.probability <= 0)
+            return DO_NOT_RECORD;
+        const draw = traceId !== undefined && isValidTraceId(traceId)
+            ? parseInt(traceId.slice(-8), 16) / 0xffffffff
+            : parseInt(generateHexId(4), 16) / 0xffffffff;
+        return draw < this.probability ? RECORD_AND_SAMPLE : DO_NOT_RECORD;
     }
 }
-/** Delegates to parent context's sampling decision, falls back to a root sampler. */
+/**
+ * Delegates to the parent's sampling decision, falling back to a root sampler.
+ *
+ * The parent's decision travels in `SpanContext.traceFlags`, which the tracer
+ * stamps on every span context it creates and every child inherits.
+ */
 export class ParentBasedSampler {
-    rootSampler;
-    constructor(rootSampler) {
-        this.rootSampler = rootSampler ?? new AlwaysOnSampler();
+    root;
+    parentSampled;
+    parentNotSampled;
+    constructor(rootOrOptions) {
+        const options = rootOrOptions !== undefined && "shouldSample" in rootOrOptions
+            ? { root: rootOrOptions }
+            : (rootOrOptions ?? {});
+        this.root = options.root ?? new AlwaysOnSampler();
+        this.parentSampled = options.remoteParentSampled ?? new AlwaysOnSampler();
+        this.parentNotSampled =
+            options.remoteParentNotSampled ?? new AlwaysOffSampler();
     }
     shouldSample(parentContext, traceId) {
         if (!parentContext) {
-            return this.rootSampler.shouldSample(parentContext, traceId);
-        }
-        // If parent is sampled, sample the child too
-        const flags = parentContext.traceFlags ?? 0;
-        if ((flags & 1) === 1) {
-            return { decision: "RECORD_AND_SAMPLE" };
+            return this.root.shouldSample(parentContext, traceId);
         }
-        return { decision: "DO_NOT_RECORD" };
+        const sampled = ((parentContext.traceFlags ?? TraceFlags.NONE) & TraceFlags.SAMPLED) ===
+            TraceFlags.SAMPLED;
+        return sampled
+            ? this.parentSampled.shouldSample(parentContext, traceId)
+            : this.parentNotSampled.shouldSample(parentContext, traceId);
     }
 }
+/** True when a sampling decision means the span should be exported. */
+export function isSampled(result) {
+    return result.decision === "RECORD_AND_SAMPLE";
+}
+/** True when a sampling decision means the span should be built at all. */
+export function isRecording(result) {
+    return result.decision !== "DO_NOT_RECORD";
+}
 /** Creates an always-on sampler. */
 export function createAlwaysOnSampler() {
     return new AlwaysOnSampler();
@@ -62,7 +103,7 @@ export function createProbabilitySampler(probability) {
     return new ProbabilitySampler(probability);
 }
 /** Creates a parent-based sampler. */
-export function createParentBasedSampler(rootSampler) {
-    return new ParentBasedSampler(rootSampler);
+export function createParentBasedSampler(rootOrOptions) {
+    return new ParentBasedSampler(rootOrOptions);
 }
 //# sourceMappingURL=sampler.type.js.map

package/dist/tracing/index.d.ts

@@ -3,6 +3,6 @@
  *
  * Distributed tracing with spans, context, and exporters.
  */
-export { DefaultSpan, createSpan, createSpanContext, createChildSpanContext, } from "./span/index.js";
-export { DefaultTracer, createTracer } from "./tracer/index.js";
+export { DefaultSpan, createSpan, createSpanContext, createChildSpanContext, isSampledContext, } from "./span/index.js";
+export { DefaultTracer, createTracer, type TracerOptions, } from "./tracer/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/tracing/index.js

@@ -3,6 +3,6 @@
  *
  * Distributed tracing with spans, context, and exporters.
  */
-export { DefaultSpan, createSpan, createSpanContext, createChildSpanContext, } from "./span/index.js";
-export { DefaultTracer, createTracer } from "./tracer/index.js";
+export { DefaultSpan, createSpan, createSpanContext, createChildSpanContext, isSampledContext, } from "./span/index.js";
+export { DefaultTracer, createTracer, } from "./tracer/index.js";
 //# sourceMappingURL=index.js.map

package/dist/tracing/span/index.d.ts

@@ -4,5 +4,5 @@
  * Span implementation and context creation.
  */
 export { DefaultSpan, createSpan } from "./span.core.js";
-export { createSpanContext, createChildSpanContext, } from "./spanContext.type.js";
+export { createSpanContext, createChildSpanContext, isSampledContext, } from "./spanContext.type.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/tracing/span/index.js

@@ -4,5 +4,5 @@
  * Span implementation and context creation.
  */
 export { DefaultSpan, createSpan } from "./span.core.js";
-export { createSpanContext, createChildSpanContext, } from "./spanContext.type.js";
+export { createSpanContext, createChildSpanContext, isSampledContext, } from "./spanContext.type.js";
 //# sourceMappingURL=index.js.map

package/dist/tracing/span/span.core.d.ts

@@ -4,11 +4,37 @@
  * In-memory span that records attributes, events, status, and errors.
  * Exported as a ReadableSpan when ended.
  */
-import type { ReadableSpan, Span, SpanContext, SpanOptions } from "../../types.js";
+import type { ReadableSpan, Span, SpanContext, SpanLimits, SpanOptions } from "../../types.js";
 import { SpanKind, SpanStatus } from "../../types.js";
+/** Extra construction options a tracer supplies alongside {@link SpanOptions}. */
+export interface SpanInternalOptions {
+    readonly resource?: Record<string, unknown>;
+    readonly limits?: SpanLimits;
+    /** Record `exception.stacktrace` on `recordError`. Default: `true`. */
+    readonly captureStackTraces?: boolean;
+    /** Called once, after `end()`, with the completed span. */
+    readonly onEnd?: (span: ReadableSpan) => void;
+    /**
+     * Redacts one attribute before it is stored.
+     *
+     * Applied inside the span rather than at the exporter, so every processor,
+     * exporter and in-process reader sees the redacted value. A span is where
+     * an `authorization` header or a request body most often lands, and the
+     * configured redaction rules used to stop at the logger.
+     */
+    readonly redactAttribute?: (key: string, value: unknown) => unknown;
+    /**
+     * A non-recording span keeps its context — so children still correlate —
+     * but drops attributes and events instead of accumulating them.
+     */
+    readonly recording?: boolean;
+}
 /**
  * Default span implementation.
+ *
  * Records attributes, events, errors, and timing until end() is called.
+ * Attribute and event counts are capped, because an unbounded span is a
+ * memory leak that only shows up under the load that produced it.
  */
 export declare class DefaultSpan implements Span {
     readonly name: string;
@@ -21,10 +47,25 @@ export declare class DefaultSpan implements Span {
     private statusMessage?;
     private endTime?;
     private ended;
-    private resource;
-    constructor(name: string, context: SpanContext, options?: SpanOptions & {
-        readonly resource?: Record<string, unknown>;
-    });
+    private droppedAttributes;
+    private droppedEvents;
+    private readonly resource;
+    private readonly limits;
+    private readonly captureStackTraces;
+    private readonly recording;
+    private readonly onEnd?;
+    private readonly redactAttribute?;
+    /**
+     * Monotonic reference for the duration. `Date` is subject to NTP steps and
+     * manual clock changes, which produce negative or inflated durations; the
+     * wall-clock timestamps stay for display.
+     */
+    private readonly startedAt;
+    private endedAt?;
+    constructor(name: string, context: SpanContext, options?: SpanOptions & SpanInternalOptions);
+    /** Redacts, then truncates — a replacement string is never itself cut. */
+    private sanitize;
+    private truncate;
     setAttribute(key: string, value: unknown): void;
     addEvent(name: string, attributes?: Record<string, unknown>): void;
     setStatus(status: SpanStatus, message?: string): void;
@@ -32,11 +73,13 @@ export declare class DefaultSpan implements Span {
     end(): void;
     getDuration(): number;
     isRecording(): boolean;
+    /** True once {@link DefaultSpan.end} has run. */
+    hasEnded(): boolean;
+    /** The message passed alongside the current status, if any. */
+    getStatusMessage(): string | undefined;
     /** Exports the span as a ReadableSpan. */
     toReadableSpan(): ReadableSpan;
 }
 /** Creates a new span. */
-export declare function createSpan(name: string, options?: SpanOptions & {
-    readonly resource?: Record<string, unknown>;
-}): DefaultSpan;
+export declare function createSpan(name: string, options?: SpanOptions & SpanInternalOptions): DefaultSpan;
 //# sourceMappingURL=span.core.d.ts.map

package/dist/tracing/span/span.core.js

@@ -6,9 +6,19 @@
  */
 import { SpanKind, SpanStatus } from "../../types.js";
 import { createSpanContext, createChildSpanContext, } from "./spanContext.type.js";
+/** Defaults matching the OpenTelemetry specification. */
+const DEFAULT_LIMITS = {
+    maxAttributes: 128,
+    maxEvents: 128,
+    maxAttributesPerEvent: 128,
+    maxAttributeValueLength: 4096,
+};
 /**
  * Default span implementation.
+ *
  * Records attributes, events, errors, and timing until end() is called.
+ * Attribute and event counts are capped, because an unbounded span is a
+ * memory leak that only shows up under the load that produced it.
  */
 export class DefaultSpan {
     name;
@@ -21,31 +31,87 @@ export class DefaultSpan {
     statusMessage;
     endTime;
     ended = false;
+    droppedAttributes = 0;
+    droppedEvents = 0;
     resource;
+    limits;
+    captureStackTraces;
+    recording;
+    onEnd;
+    redactAttribute;
+    /**
+     * Monotonic reference for the duration. `Date` is subject to NTP steps and
+     * manual clock changes, which produce negative or inflated durations; the
+     * wall-clock timestamps stay for display.
+     */
+    startedAt;
+    endedAt;
     constructor(name, context, options) {
         this.name = name;
         this.context = context;
         this.kind = options?.kind ?? SpanKind.INTERNAL;
         this.startTime = new Date();
+        this.startedAt = performance.now();
         this.resource = { ...(options?.resource ?? {}) };
+        this.limits = { ...DEFAULT_LIMITS, ...(options?.limits ?? {}) };
+        this.captureStackTraces = options?.captureStackTraces ?? true;
+        this.recording = options?.recording ?? true;
+        this.onEnd = options?.onEnd;
+        this.redactAttribute = options?.redactAttribute;
         if (options?.attributes) {
             for (const [key, value] of Object.entries(options.attributes)) {
-                this.attributes[key] = value;
+                this.setAttribute(key, value);
             }
         }
     }
+    /** Redacts, then truncates — a replacement string is never itself cut. */
+    sanitize(key, value) {
+        const redacted = this.redactAttribute
+            ? this.redactAttribute(key, value)
+            : value;
+        return this.truncate(redacted);
+    }
+    truncate(value) {
+        if (typeof value === "string" &&
+            value.length > this.limits.maxAttributeValueLength) {
+            return value.slice(0, this.limits.maxAttributeValueLength);
+        }
+        return value;
+    }
     setAttribute(key, value) {
-        if (this.ended)
+        if (this.ended || !this.recording)
+            return;
+        if (!(key in this.attributes) &&
+            Object.keys(this.attributes).length >= this.limits.maxAttributes) {
+            this.droppedAttributes++;
             return;
-        this.attributes[key] = value;
+        }
+        this.attributes[key] = this.sanitize(key, value);
     }
     addEvent(name, attributes) {
-        if (this.ended)
+        if (this.ended || !this.recording)
+            return;
+        if (this.events.length >= this.limits.maxEvents) {
+            this.droppedEvents++;
             return;
+        }
+        let eventAttributes;
+        if (attributes) {
+            eventAttributes = {};
+            let kept = 0;
+            for (const [key, value] of Object.entries(attributes)) {
+                if (kept >= this.limits.maxAttributesPerEvent) {
+                    this.droppedAttributes++;
+                    continue;
+                }
+                eventAttributes[key] = this.sanitize(key, value);
+                kept++;
+            }
+        }
         this.events.push({
             name,
             timestamp: new Date(),
-            attributes,
+            attributes: eventAttributes,
         });
     }
     setStatus(status, message) {
@@ -62,7 +128,9 @@ export class DefaultSpan {
         this.addEvent("exception", {
             "exception.type": error.name,
             "exception.message": error.message,
-            "exception.stacktrace": error.stack,
+            ...(this.captureStackTraces
+                ? { "exception.stacktrace": error.stack }
+                : {}),
         });
     }
     end() {
@@ -70,14 +138,23 @@ export class DefaultSpan {
             return;
         this.ended = true;
         this.endTime = new Date();
+        this.endedAt = performance.now();
+        this.onEnd?.(this.toReadableSpan());
     }
     getDuration() {
-        if (!this.endTime)
-            return Date.now() - this.startTime.getTime();
-        return this.endTime.getTime() - this.startTime.getTime();
+        const finished = this.endedAt ?? performance.now();
+        return finished - this.startedAt;
     }
     isRecording() {
-        return !this.ended;
+        return !this.ended && this.recording;
+    }
+    /** True once {@link DefaultSpan.end} has run. */
+    hasEnded() {
+        return this.ended;
+    }
+    /** The message passed alongside the current status, if any. */
+    getStatusMessage() {
+        return this.statusMessage;
     }
     /** Exports the span as a ReadableSpan. */
     toReadableSpan() {
@@ -89,9 +166,12 @@ export class DefaultSpan {
             endTime: this.endTime ?? new Date(),
             duration: this.getDuration(),
             status: this.status,
+            statusMessage: this.statusMessage,
             attributes: { ...this.attributes },
             events: [...this.events],
             resource: { ...this.resource },
+            droppedAttributes: this.droppedAttributes,
+            droppedEvents: this.droppedEvents,
         };
     }
 }

package/dist/tracing/span/spanContext.type.d.ts

@@ -4,13 +4,22 @@
  * Factory for creating span context identifiers.
  */
 import type { SpanContext } from "../../types.js";
-/** Creates a new span context with random IDs. */
+/** Creates a new span context with cryptographically random IDs. */
 export declare function createSpanContext(options?: {
     readonly traceId?: string;
     readonly spanId?: string;
     readonly parentSpanId?: string;
     readonly traceFlags?: number;
 }): SpanContext;
-/** Creates a child span context from a parent. */
-export declare function createChildSpanContext(parent: SpanContext): SpanContext;
+/**
+ * Creates a child span context from a parent.
+ *
+ * The trace ID and the trace flags both carry over: dropping the flags is
+ * what makes a parent-based sampler discard every child of a sampled trace.
+ */
+export declare function createChildSpanContext(parent: SpanContext, overrides?: {
+    readonly traceFlags?: number;
+}): SpanContext;
+/** True when the context carries the W3C sampled flag. */
+export declare function isSampledContext(context: SpanContext): boolean;
 //# sourceMappingURL=spanContext.type.d.ts.map

package/dist/tracing/span/spanContext.type.js

@@ -3,30 +3,33 @@
  *
  * Factory for creating span context identifiers.
  */
-/** Generates a random hex ID. */
-function generateHexId(byteLength) {
-    const bytes = new Uint8Array(byteLength);
-    for (let i = 0; i < byteLength; i++) {
-        bytes[i] = Math.floor(Math.random() * 256);
-    }
-    return Array.from(bytes)
-        .map((b) => b.toString(16).padStart(2, "0"))
-        .join("");
-}
-/** Creates a new span context with random IDs. */
+import { TraceFlags } from "../../types.js";
+import { generateSpanId, generateTraceId } from "../../internal/index.js";
+/** Creates a new span context with cryptographically random IDs. */
 export function createSpanContext(options) {
     return {
-        traceId: options?.traceId ?? generateHexId(16),
-        spanId: options?.spanId ?? generateHexId(8),
+        traceId: options?.traceId ?? generateTraceId(),
+        spanId: options?.spanId ?? generateSpanId(),
         parentSpanId: options?.parentSpanId,
-        traceFlags: options?.traceFlags,
+        traceFlags: options?.traceFlags ?? TraceFlags.NONE,
     };
 }
-/** Creates a child span context from a parent. */
-export function createChildSpanContext(parent) {
+/**
+ * Creates a child span context from a parent.
+ *
+ * The trace ID and the trace flags both carry over: dropping the flags is
+ * what makes a parent-based sampler discard every child of a sampled trace.
+ */
+export function createChildSpanContext(parent, overrides) {
     return createSpanContext({
         traceId: parent.traceId,
         parentSpanId: parent.spanId,
+        traceFlags: overrides?.traceFlags ?? parent.traceFlags ?? TraceFlags.NONE,
     });
 }
+/** True when the context carries the W3C sampled flag. */
+export function isSampledContext(context) {
+    return (((context.traceFlags ?? TraceFlags.NONE) & TraceFlags.SAMPLED) ===
+        TraceFlags.SAMPLED);
+}
 //# sourceMappingURL=spanContext.type.js.map

package/dist/tracing/tracer/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * @zudojs/observability — Tracer
  *
- * Span creation and processor notification.
+ * Span creation, sampling, and processor notification.
  */
-export { DefaultTracer, createTracer } from "./tracer.core.js";
+export { DefaultTracer, createTracer, type TracerOptions, } from "./tracer.core.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/tracing/tracer/index.js

@@ -1,7 +1,7 @@
 /**
  * @zudojs/observability — Tracer
  *
- * Span creation and processor notification.
+ * Span creation, sampling, and processor notification.
  */
-export { DefaultTracer, createTracer } from "./tracer.core.js";
+export { DefaultTracer, createTracer, } from "./tracer.core.js";
 //# sourceMappingURL=index.js.map

package/dist/tracing/tracer/tracer.core.d.ts

@@ -1,9 +1,34 @@
 /**
  * @zudojs/observability — Tracer
  *
- * Creates spans and notifies processors on start/end.
+ * Creates spans, applies the sampling decision, and notifies processors on
+ * start and end.
  */
-import type { ReadableSpan, Span, SpanExporter, SpanOptions, SpanProcessor, Tracer } from "../../types.js";
+import type { ReadableSpan, Sampler, Span, SpanExporter, SpanLimits, SpanOptions, SpanProcessor, Tracer } from "../../types.js";
+/** Options for {@link DefaultTracer}. */
+export interface TracerOptions {
+    readonly processors?: readonly SpanProcessor[];
+    /**
+     * Exporter used by {@link DefaultTracer.exportSpan} for a direct, unbatched
+     * export. Spans created through {@link DefaultTracer.startSpan} reach their
+     * backend through the processors, not through this.
+     */
+    readonly exporter?: SpanExporter;
+    readonly resource?: Record<string, unknown>;
+    /** Decides which traces are recorded. Default: always on. */
+    readonly sampler?: Sampler;
+    /** Caps on what a single span may accumulate. */
+    readonly limits?: SpanLimits;
+    /** Record `exception.stacktrace` on `recordError`. Default: `true`. */
+    readonly captureStackTraces?: boolean;
+    /**
+     * Redacts every span attribute and event attribute before it is recorded.
+     * Supply one whenever spans can carry request data.
+     */
+    readonly redactAttribute?: (key: string, value: unknown) => unknown;
+    /** Reports a processor failure that would otherwise be swallowed. */
+    readonly onError?: (error: unknown, source: string) => void;
+}
 /**
  * Default tracer that creates spans and notifies processors on start/end.
  */
@@ -11,21 +36,26 @@ export declare class DefaultTracer implements Tracer {
     private readonly processors;
     private readonly exporter?;
     private readonly resource;
-    constructor(options?: {
-        readonly processors?: readonly SpanProcessor[];
-        readonly exporter?: SpanExporter;
-        readonly resource?: Record<string, unknown>;
-    });
+    private readonly sampler;
+    private readonly limits?;
+    private readonly captureStackTraces;
+    private readonly redactAttribute?;
+    private readonly onError?;
+    constructor(options?: TracerOptions);
     startSpan(name: string, options?: SpanOptions): Span;
-    /** Exports a completed span directly. */
+    private notifyEnd;
+    /** Exports a completed span directly, bypassing the processors. */
     exportSpan(span: ReadableSpan): Promise<void>;
-    /** Shuts down all processors and the exporter. */
+    /** Drains every processor without shutting anything down. */
+    forceFlush(): Promise<void>;
+    /**
+     * Shuts down every processor.
+     *
+     * The exporter is not shut down here: the owner that supplied it shuts it
+     * down, and doing it in both places closed the same connection twice.
+     */
     shutdown(): Promise<void>;
 }
 /** Creates a tracer. */
-export declare function createTracer(options?: {
-    readonly processors?: readonly SpanProcessor[];
-    readonly exporter?: SpanExporter;
-    readonly resource?: Record<string, unknown>;
-}): DefaultTracer;
+export declare function createTracer(options?: TracerOptions): DefaultTracer;
 //# sourceMappingURL=tracer.core.d.ts.map