@logbrew/sdk 0.1.3 → 0.1.4

package/index.d.cts

@@ -18,6 +18,14 @@ export type TraceparentContext = {
   sampled: boolean;
 };
 
+/** Minimal active trace shape accepted by logger adapters for correlation metadata. */
+export type LogCorrelationTraceContext = {
+  traceId: string;
+  spanId: string;
+  parentSpanId?: string;
+  sampled?: boolean;
+};
+
 /** Inputs for creating a W3C traceparent value from known trace/span ids. */
 export type TraceparentInput = {
   traceId: string;
@@ -25,13 +33,176 @@ export type TraceparentInput = {
   traceFlags?: string;
 };
 
+/** Privacy-bounded W3C tracestate entry for explicit propagation. */
+export type TracestateEntry = {
+  key: string;
+  value: string;
+};
+
+/** W3C baggage entry for explicit propagation. */
+export type BaggageEntry = {
+  key: string;
+  value: string;
+  properties?: string[];
+};
+
+/** Inputs for creating an explicit W3C trace context header carrier. */
+export type TraceContextInput = TraceparentInput & {
+  tracestate?: string | TracestateEntry[];
+  baggage?: string | BaggageEntry[];
+};
+
+/** Minimal OpenTelemetry SpanContext-like shape copied by dependency-free bridge helpers. */
+export type OpenTelemetrySpanContextLike = {
+  traceId?: unknown;
+  spanId?: unknown;
+  traceFlags?: unknown;
+  isValid?: boolean;
+};
+
+/** Minimal OpenTelemetry Span-like shape accepted by dependency-free bridge helpers. */
+export type OpenTelemetrySpanLike = {
+  spanContext?: () => OpenTelemetrySpanContextLike | null | undefined;
+  getSpanContext?: () => OpenTelemetrySpanContextLike | null | undefined;
+};
+
+/** Minimal OpenTelemetry API-like shape used for the current active span helper. */
+export type OpenTelemetryApiLike = {
+  trace?: {
+    getActiveSpan?: () => OpenTelemetrySpanLike | null | undefined;
+  };
+};
+
+/** OpenTelemetry high-resolution time tuple accepted by dependency-free ReadableSpan helpers. */
+export type OpenTelemetryHrTimeLike = readonly [number, number];
+
+/** Minimal OpenTelemetry event-like shape summarized from ended spans. */
+export type OpenTelemetryTimedEventLike = {
+  name?: unknown;
+  time?: OpenTelemetryHrTimeLike | number | Date;
+  timestamp?: OpenTelemetryHrTimeLike | number | Date;
+  attributes?: Record<string, unknown>;
+};
+
+/** Minimal OpenTelemetry link-like shape summarized from ended spans. */
+export type OpenTelemetrySpanLinkLike = {
+  context?: OpenTelemetrySpanContextLike | null | undefined;
+  spanContext?: OpenTelemetrySpanContextLike | null | undefined;
+  attributes?: Record<string, unknown>;
+};
+
+/** Minimal OpenTelemetry ReadableSpan-like shape accepted by dependency-free bridge helpers. */
+export type OpenTelemetryReadableSpanLike = {
+  name?: unknown;
+  kind?: unknown;
+  spanContext?: () => OpenTelemetrySpanContextLike | null | undefined;
+  parentSpanContext?: OpenTelemetrySpanContextLike | null | undefined;
+  parentSpanId?: unknown;
+  startTime?: OpenTelemetryHrTimeLike | number | Date;
+  endTime?: OpenTelemetryHrTimeLike | number | Date;
+  duration?: OpenTelemetryHrTimeLike;
+  status?: { code?: unknown };
+  attributes?: Record<string, unknown>;
+  events?: OpenTelemetryTimedEventLike[];
+  links?: OpenTelemetrySpanLinkLike[];
+  resource?: { attributes?: Record<string, unknown> };
+  instrumentationScope?: { name?: unknown; version?: unknown };
+  droppedAttributesCount?: unknown;
+  droppedEventsCount?: unknown;
+  droppedLinksCount?: unknown;
+};
+
+/** Options for creating a LogBrew child trace from OpenTelemetry context. */
+export type OpenTelemetryTraceContextOptions = {
+  spanId?: string;
+  spanIdFactory?: () => string;
+};
+
+/** Options for reading OpenTelemetry's current active span without requiring an OTel dependency. */
+export type CurrentOpenTelemetryTraceContextOptions = OpenTelemetryTraceContextOptions & {
+  openTelemetryApi?: OpenTelemetryApiLike;
+};
+
+/** Options for privacy-bounded OpenTelemetry ReadableSpan conversion. */
+export type OpenTelemetryReadableSpanOptions = {
+  /** Additional safe span attribute keys to copy; sensitive keys remain blocked. */
+  attributeKeys?: string[];
+  /** Capture unsampled spans. Defaults to false to follow common OTel processor behavior. */
+  captureUnsampled?: boolean;
+  /** Additional safe span event attribute keys to copy; sensitive keys remain blocked. */
+  eventAttributeKeys?: string[];
+  /** Include privacy-bounded span event summaries. Defaults to true. */
+  includeSpanEvents?: boolean;
+  /** Include privacy-bounded span link summaries. Defaults to true. */
+  includeSpanLinks?: boolean;
+  /** Additional safe span link attribute keys to copy; sensitive keys remain blocked. */
+  linkAttributeKeys?: string[];
+  /** Primitive app metadata merged into every converted span. */
+  metadata?: Metadata;
+  /** Additional safe resource attribute keys to copy; sensitive keys remain blocked. */
+  resourceAttributeKeys?: string[];
+};
+
+/** Configuration for an opt-in OpenTelemetry SpanProcessor-compatible LogBrew bridge. */
+export type OpenTelemetrySpanProcessorConfig = OpenTelemetryReadableSpanOptions & {
+  client: LogBrewClient;
+  transport?: Transport;
+  flushOnForceFlush?: boolean;
+  /** Emit one privacy-bounded synthetic trace summary span per trace on forceFlush/shutdown. Defaults to false. */
+  includeTraceSummary?: boolean;
+  timestamp?: () => string;
+  eventIdPrefix?: string;
+  spanFilter?: (span: unknown) => boolean | void;
+  onError?: (error: unknown) => void;
+};
+
+/** Configuration for an opt-in OpenTelemetry SpanExporter-compatible LogBrew bridge. */
+export type OpenTelemetrySpanExporterConfig = OpenTelemetryReadableSpanOptions & {
+  client: LogBrewClient;
+  transport?: Transport;
+  /** Flush with the provided transport during export. Defaults to true when a transport is supplied. */
+  flushOnExport?: boolean;
+  /** Emit one privacy-bounded synthetic trace summary span per exported batch. Defaults to false. */
+  includeTraceSummary?: boolean;
+  timestamp?: () => string;
+  eventIdPrefix?: string;
+  spanFilter?: (span: unknown) => boolean | void;
+  onError?: (error: unknown) => void;
+};
+
+/** Minimal OpenTelemetry export result shape; success is code 0, failure is code 1. */
+export type OpenTelemetryExportResult = {
+  code: number;
+  error?: Error;
+};
+
+/** SpanExporter-compatible handle for app-owned OpenTelemetry processors. */
+export type OpenTelemetrySpanExporterHandle = {
+  export(
+    spans: readonly (OpenTelemetryReadableSpanLike | unknown)[],
+    resultCallback: (result: OpenTelemetryExportResult) => void
+  ): void;
+  forceFlush(): Promise<void>;
+  shutdown(): Promise<void>;
+};
+
+/** SpanProcessor-compatible handle for app-owned OpenTelemetry setup. */
+export type OpenTelemetrySpanProcessorHandle = {
+  onStart(span: unknown, parentContext: unknown): void;
+  onEnd(span: OpenTelemetryReadableSpanLike | unknown): void;
+  forceFlush(): Promise<void>;
+  shutdown(): Promise<void>;
+};
+
 /** Span fields supplied when deriving LogBrew span attributes from traceparent. */
 export type TraceparentSpanInput = {
   name: string;
   spanId: string;
   status: "ok" | "error";
   durationMs?: number;
+  links?: SpanLinkSummary[];
   metadata?: Metadata;
+  events?: SpanEventSummary[];
 };
 
 /** Public release event attributes. */
@@ -49,12 +220,54 @@ export type EnvironmentAttributes = {
   metadata?: Metadata;
 };
 
+/** Privacy-bounded generated JavaScript frame attached to an issue. */
+export type IssueStackFrame = {
+  /** Query-free generated filename or URL with local absolute prefixes removed. */
+  filename: string;
+  /** One-based generated source line. */
+  line: number;
+  /** One-based generated source column. */
+  column: number;
+  /** Optional release-artifact Debug ID matched to this generated file. */
+  debugId?: string;
+};
+
 /** Public issue event attributes. */
 export type IssueAttributes = {
   title: string;
   level: SeverityInput;
   message?: string;
+  /** Ordered privacy-bounded generated frames, capped at 32. */
+  stackFrames?: IssueStackFrame[];
+  metadata?: Metadata;
+};
+
+/** Options for creating privacy-bounded issue attributes from a JavaScript error. */
+export type JavaScriptErrorIssueOptions = {
+  title?: string;
+  level?: SeverityInput;
+  message?: string;
   metadata?: Metadata;
+  /** Metadata source label. Defaults to `javascript.error`. */
+  source?: string;
+  /** Active trace copied into primitive correlation metadata. */
+  trace?: LogCorrelationTraceContext | null;
+  /** Release name associated with the runtime error. */
+  release?: string;
+  /** Environment associated with the runtime error. */
+  environment?: string;
+  /** Service associated with the runtime error. */
+  service?: string;
+  /** Runtime label such as `browser`, `node`, or `react-native`. */
+  runtime?: string;
+  /** Platform label such as `web`, `ios`, or `android`. */
+  platform?: string;
+  /** Map of sanitized frame filenames or minified URLs to release-artifact Debug IDs. */
+  debugIdMap?: Record<string, string>;
+  /** Optional stable app-owned grouping fingerprint. Keep it safe and low-cardinality. */
+  fingerprint?: string;
+  /** Include raw stack text only when the app has explicitly approved it. Defaults to false. */
+  includeErrorStack?: boolean;
 };
 
 /** Public log event attributes. */
@@ -108,6 +321,7 @@ export type PinoDestinationConfig = {
   client: LogBrewClient;
   logger?: string;
   metadata?: Metadata;
+  traceProvider?: () => LogCorrelationTraceContext | null | undefined;
   transport?: Transport;
   flushOnWrite?: boolean;
   includeErrorStack?: boolean;
@@ -139,6 +353,7 @@ export type WinstonTransportConfig = {
   client: LogBrewClient;
   logger?: string;
   metadata?: Metadata;
+  traceProvider?: () => LogCorrelationTraceContext | null | undefined;
   transport?: Transport;
   flushOnWrite?: boolean;
   includeErrorStack?: boolean;
@@ -165,6 +380,21 @@ export type WinstonTransportHandle = {
   end(callback?: () => void): unknown;
 };
 
+/** Privacy-bounded milestone recorded inside a span. */
+export type SpanEventSummary = {
+  name: string;
+  timestamp?: string;
+  metadata?: Metadata;
+};
+
+/** Privacy-bounded reference from this span to another trace/span. */
+export type SpanLinkSummary = {
+  traceId: string;
+  spanId: string;
+  sampled?: boolean;
+  metadata?: Metadata;
+};
+
 /** Public span event attributes. */
 export type SpanAttributes = {
   name: string;
@@ -173,6 +403,8 @@ export type SpanAttributes = {
   parentSpanId?: string;
   status: "ok" | "error";
   durationMs?: number;
+  events?: SpanEventSummary[];
+  links?: SpanLinkSummary[];
   metadata?: Metadata;
 };
 
@@ -214,6 +446,67 @@ export type TimelineAttributesOptions = {
   metadata?: Metadata;
 };
 
+/** Planned backend support-ticket sources accepted by explicit draft helpers. */
+export type SupportTicketSource = "cli" | "sdk" | "website" | "docs" | "mobile";
+
+/** Planned backend support-ticket categories accepted by explicit draft helpers. */
+export type SupportTicketCategory =
+  | "sdk_install_failure"
+  | "ingest_failure"
+  | "auth_failure"
+  | "project_setup"
+  | "dashboard_issue"
+  | "docs_confusion"
+  | "cli_issue"
+  | "mobile_issue"
+  | "billing_question"
+  | "other";
+
+/** JSON-like diagnostics input sanitized before a support-ticket draft is returned. */
+export type SupportDiagnosticsValue =
+  | string
+  | number
+  | boolean
+  | null
+  | SupportDiagnosticsValue[]
+  | { [key: string]: SupportDiagnosticsValue };
+
+/** Explicit local-only support-ticket draft input. This does not open a ticket. */
+export type SupportTicketDraftInput = {
+  source: SupportTicketSource;
+  category: SupportTicketCategory;
+  title: string;
+  description: string;
+  projectId?: string;
+  environment?: string;
+  runtime?: string;
+  framework?: string;
+  sdkPackage?: string;
+  sdkVersion?: string;
+  release?: string;
+  traceId?: string;
+  eventId?: string;
+  diagnostics?: Record<string, unknown>;
+};
+
+/** Planned backend create payload produced locally for explicit user or agent action. */
+export type SupportTicketDraft = {
+  source: SupportTicketSource;
+  category: SupportTicketCategory;
+  title: string;
+  description: string;
+  project_id?: string;
+  environment?: string;
+  runtime?: string;
+  framework?: string;
+  sdk_package?: string;
+  sdk_version?: string;
+  release?: string;
+  trace_id?: string;
+  event_id?: string;
+  diagnostics?: Record<string, SupportDiagnosticsValue>;
+};
+
 /** Public metric event attributes. Use low-cardinality metadata only. */
 export type MetricAttributes = {
   name: string;
@@ -244,12 +537,40 @@ export type Event =
 /** Drop-only event filter called after validation and before an event is queued. */
 export type EventFilter = (event: Event) => boolean | void;
 
+/** Canonical compact event record exchanged with an app-owned synchronous persistence adapter. */
+export type StoredEvent = {
+  event: Event;
+  serializedEvent: string;
+  eventBytes: number;
+};
+
+/** Explicit synchronous persistence seam used to recover and acknowledge queued events safely. */
+export type EventStore = {
+  load(): StoredEvent[];
+  append(record: StoredEvent): void;
+  acknowledge(count: number): void;
+  purge(): void;
+  close(): void;
+};
+
+/** Queue drop notification emitted when a bounded in-memory queue is full. */
+export type DroppedEvent = {
+  reason: "event_too_large" | "queue_bytes_overflow" | "queue_overflow";
+  eventType: Event["type"];
+  eventId: string;
+  droppedEvents: number;
+};
+
 /** Stable transport response returned from flush and shutdown operations. */
 export type TransportResponse = {
   /** Final HTTP-like status returned by the transport. */
   statusCode: number;
   /** Number of transport attempts used for the flush. */
   attempts: number;
+  /** Number of distinct batches acknowledged; client flush/shutdown responses always include it. */
+  batches?: number;
+  /** Optional retry delay from a rate-limit response, in milliseconds. */
+  retryAfterMs?: number;
 };
 
 /** Minimal transport interface accepted by flush and shutdown operations. */
@@ -257,10 +578,54 @@ export type Transport = {
   send(apiKey: string, body: string): TransportResponse | Promise<TransportResponse>;
 };
 
+/** Content-free bounded delivery state with no event or sensitive transport fields. */
+export type DeliveryHealthSnapshot = Readonly<{
+  /** Stable schema discriminator for JSON consumers. */
+  schemaVersion: 1;
+  automaticDelivery: boolean;
+  lifecycle: "active" | "shutting_down" | "closed";
+  deliveryState: "idle" | "queued" | "scheduled" | "in_flight" | "retrying" | "paused" | "accepted" | "failed" | "dropped";
+  storage: "memory" | "persistent";
+  queueEvents: number;
+  queueBytes: number;
+  /** Events and compact bytes loaded from persistence when this client started. */
+  hydratedEvents: number;
+  hydratedBytes: number;
+  droppedEvents: number;
+  droppedByReason: Readonly<{
+    event_too_large: number;
+    queue_bytes_overflow: number;
+    queue_overflow: number;
+  }>;
+  lastDropReason: "none" | "event_too_large" | "queue_bytes_overflow" | "queue_overflow";
+  scheduled: boolean;
+  inFlight: boolean;
+  coalesced: boolean;
+  pendingOperations: number;
+  lastOutcome: "idle" | "empty" | "accepted" | "failed";
+  lastStatusClass: "none" | "success" | "client_error" | "server_error" | "network_error" | "transport_error" | "invalid_response" | "other_status";
+  pausedReason: "none" | "authentication" | "rate_limit" | "non_retryable";
+  consecutiveFailures: number;
+  /** Bounded transient retry delay; zero when no automatic retry is scheduled. */
+  retryDelayMs: number;
+  flushes: number;
+  failures: number;
+  attempts: number;
+  batches: number;
+  /** Events durably acknowledged since this client was created. */
+  acceptedEvents: number;
+  /** Bounded monotonic-within-client Unix milliseconds; zero until the transition occurs. */
+  lastAttemptAtUnixMs: number;
+  lastAcceptedAtUnixMs: number;
+  lastDroppedAtUnixMs: number;
+}>;
+
 /** Stable public SDK error with parseable code and message fields. */
 export declare class SdkError extends Error {
   code: string;
-  constructor(code: string, message: string);
+  retryAfterMs?: number;
+  retryable?: boolean;
+  constructor(code: string, message: string, details?: { retryAfterMs?: number; retryable?: boolean });
 }
 
 /** Transport error that can optionally be marked retryable by the caller. */
@@ -274,7 +639,7 @@ export declare class TransportError extends Error {
 
 /** Scripted transport for previewing, accepting, or failing queued event flushes. */
 export declare class RecordingTransport {
-  constructor(scriptedResponses?: Array<{ statusCode: number } | Error>);
+  constructor(scriptedResponses?: Array<{ statusCode: number; retryAfterMs?: number } | Error>);
   /** Every request body sent through this transport instance. */
   sentBodies: string[];
   /** Create a transport that accepts queued flushes with a 202 response. */
@@ -291,13 +656,40 @@ export declare class LogBrewClient {
     apiKey: string;
     sdkName: string;
     sdkVersion: string;
+    /** Retry attempts after the first send. Must be a non-negative integer; defaults to 2. */
     maxRetries?: number;
     eventFilter?: EventFilter;
+    /** Maximum queued compact event bytes. Defaults to 4 MiB. */
+    maxQueueBytes?: number;
+    maxQueueSize?: number;
+    /** Maximum events per request body. Defaults to 100. */
+    maxBatchEvents?: number;
+    /** Maximum UTF-8 request body bytes. Defaults to 256 KiB. */
+    maxBatchBytes?: number;
+    onEventDropped?: (drop: DroppedEvent) => void;
+    /** Optional app-scoped persistence adapter. Methods must complete synchronously. */
+    eventStore?: EventStore;
+    /** Client-owned transport used by automatic delivery and by flush/shutdown when no argument is supplied. */
+    transport?: Transport;
+    /** Enable interval and queue-threshold delivery. Defaults to true when transport is supplied. */
+    automaticDelivery?: boolean;
+    /** One-shot delivery interval in milliseconds. Defaults to 5000 and must not exceed 60000. */
+    deliveryIntervalMs?: number;
+    /** Queue count that triggers delivery without waiting for the interval. Defaults to min(50, maxQueueSize). */
+    deliveryQueueThreshold?: number;
   }): LogBrewClient;
   /** Return the queued event count currently buffered in memory. */
   pendingEvents(): number;
+  /** Return compact serialized event bytes currently buffered in memory. */
+  pendingBytes(): number;
+  /** Return the number of events dropped because the bounded in-memory queue was full. */
+  droppedEvents(): number;
+  /** Return a frozen, content-free snapshot of queue and delivery lifecycle health. */
+  deliveryHealth(): DeliveryHealthSnapshot;
   /** Return the queued event batch as stable, pretty-printed JSON. */
   previewJson(): string;
+  /** Purge queued events from memory and persistence while no delivery operation is active. */
+  purgePendingEvents(): number;
   release(id: string, timestamp: string, attributes: ReleaseAttributes): void;
   environment(id: string, timestamp: string, attributes: EnvironmentAttributes): void;
   issue(id: string, timestamp: string, attributes: IssueAttributes): void;
@@ -305,10 +697,10 @@ export declare class LogBrewClient {
   span(id: string, timestamp: string, attributes: SpanAttributes): void;
   action(id: string, timestamp: string, attributes: ActionAttributes): void;
   metric(id: string, timestamp: string, attributes: MetricAttributes): void;
-  /** Flush queued events through a transport while preserving retry semantics. */
-  flush(transport: Transport): Promise<TransportResponse>;
-  /** Flush queued events, then mark the client closed so later writes fail. */
-  shutdown(transport: Transport): Promise<TransportResponse>;
+  /** Flush one queue snapshot in bounded batches while preserving concurrent captures and retry bodies. */
+  flush(transport?: Transport): Promise<TransportResponse>;
+  /** Reject new capture, flush queued events, then close; a failed flush reopens the intact remainder. */
+  shutdown(transport?: Transport): Promise<TransportResponse>;
 }
 
 /** Install explicit console capture while preserving the target console's normal output behavior. */
@@ -326,6 +718,15 @@ export declare function createNetworkMilestoneAttributes(
   options?: TimelineAttributesOptions
 ): ActionAttributes;
 
+/** Build a local-only, token-free support-ticket create payload draft without calling backend routes. */
+export declare function createSupportTicketDraft(input: SupportTicketDraftInput): SupportTicketDraft;
+
+/** Convert a JavaScript Error-like value into safe issue attributes with optional source-map Debug ID metadata. */
+export declare function createIssueAttributesFromError(
+  error: unknown,
+  options?: JavaScriptErrorIssueOptions
+): IssueAttributes;
+
 /** Convert console arguments into safe LogBrew log attributes without installing capture. */
 export declare function logAttributesFromConsoleArgs(
   method: ConsoleMethodName,
@@ -349,6 +750,58 @@ export declare function createTraceparent(input: TraceparentInput): string;
 /** Create an explicit outbound header carrier containing only traceparent. */
 export declare function createTraceparentHeaders(input: TraceparentInput): { traceparent: string };
 
+/** Parse a W3C tracestate header into normalized entries. */
+export declare function parseTracestate(tracestate: string): TracestateEntry[];
+
+/** Create a normalized W3C tracestate header from explicit entries. */
+export declare function createTracestate(entries: TracestateEntry[]): string;
+
+/** Parse a W3C baggage header into decoded entries. */
+export declare function parseBaggage(baggage: string): BaggageEntry[];
+
+/** Create a W3C baggage header from explicit entries. */
+export declare function createBaggage(entries: BaggageEntry[]): string;
+
+/** Create an explicit outbound carrier for traceparent plus optional tracestate and baggage. */
+export declare function createTraceContextHeaders(input: TraceContextInput): {
+  traceparent: string;
+  tracestate?: string;
+  baggage?: string;
+};
+
+/** Create a LogBrew child trace from a live OpenTelemetry SpanContext-like object. */
+export declare function logbrewTraceContextFromOpenTelemetrySpanContext(
+  spanContext: OpenTelemetrySpanContextLike | null | undefined,
+  options?: OpenTelemetryTraceContextOptions
+): LogCorrelationTraceContext | null;
+
+/** Create a LogBrew child trace from a live OpenTelemetry Span-like object. */
+export declare function logbrewTraceContextFromOpenTelemetrySpan(
+  span: OpenTelemetrySpanLike | null | undefined,
+  options?: OpenTelemetryTraceContextOptions
+): LogCorrelationTraceContext | null;
+
+/** Create a LogBrew child trace from OpenTelemetry's current active span, when available. */
+export declare function logbrewTraceContextFromCurrentOpenTelemetrySpan(
+  options?: CurrentOpenTelemetryTraceContextOptions
+): LogCorrelationTraceContext | null;
+
+/** Convert an ended OpenTelemetry ReadableSpan-like object into safe LogBrew span attributes. */
+export declare function spanAttributesFromOpenTelemetryReadableSpan(
+  span: OpenTelemetryReadableSpanLike | null | undefined,
+  options?: OpenTelemetryReadableSpanOptions
+): SpanAttributes | null;
+
+/** Create an opt-in SpanProcessor-compatible bridge for app-owned OpenTelemetry providers. */
+export declare function createLogBrewOpenTelemetrySpanProcessor(
+  config: OpenTelemetrySpanProcessorConfig
+): OpenTelemetrySpanProcessorHandle;
+
+/** Create an opt-in SpanExporter-compatible bridge for app-owned OpenTelemetry processors. */
+export declare function createLogBrewOpenTelemetrySpanExporter(
+  config: OpenTelemetrySpanExporterConfig
+): OpenTelemetrySpanExporterHandle;
+
 /** Build LogBrew span attributes that continue an incoming W3C traceparent value. */
 export declare function spanAttributesFromTraceparent(
   traceparent: string,
@@ -364,6 +817,7 @@ export declare function logAttributesFromPinoRecord(
   options?: {
     logger?: string;
     metadata?: Metadata;
+    trace?: LogCorrelationTraceContext | null;
     includeErrorStack?: boolean;
   }
 ): LogAttributes;
@@ -377,6 +831,7 @@ export declare function logAttributesFromWinstonInfo(
   options?: {
     logger?: string;
     metadata?: Metadata;
+    trace?: LogCorrelationTraceContext | null;
     includeErrorStack?: boolean;
   }
 ): LogAttributes;