@logbrew/sdk 0.1.37 → 0.1.39

package/types/client.d.ts

@@ -0,0 +1,67 @@
+import type { ActionAttributes, EnvironmentAttributes, LogAttributes, MetricAttributes, ReleaseAttributes, SpanAttributes, TelemetryContext } from "./telemetry.js";
+import type { DeliveryHealthSnapshot, DroppedEvent, EventFilter, EventStore, IssueAdmission, Transport, TransportResponse } from "./delivery.js";
+import type { IssueAttributes, IssueBreadcrumbInput } from "./issues.js";
+
+/** Buffered public client for validating, previewing, and flushing LogBrew events. */
+declare class LogBrewClient {
+  /** Create a client from public SDK identity, retry, and API key settings. */
+  public static create(config: {
+    apiKey: string;
+    sdkName: string;
+    sdkVersion: string;
+    /** Versioned context merged into every captured event; event context can override dynamic fields. */
+    context?: TelemetryContext;
+    /** 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 1000 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. */
+  public pendingEvents(): number;
+  /** Return compact serialized event bytes currently buffered in memory. */
+  public pendingBytes(): number;
+  /** Return the number of events dropped because the bounded in-memory queue was full. */
+  public droppedEvents(): number;
+  /** Return a frozen, content-free snapshot of queue and delivery lifecycle health. */
+  public deliveryHealth(): DeliveryHealthSnapshot;
+  /** Return the queued event batch as stable, pretty-printed JSON. */
+  public previewJson(): string;
+  /** Purge queued events from memory and persistence while no delivery operation is active. */
+  public purgePendingEvents(): number;
+  /** Add one explicit privacy-bounded breadcrumb to the client's 64-entry issue history. */
+  public addBreadcrumb(breadcrumb: IssueBreadcrumbInput, timestamp?: string): void;
+  /** Clear the current issue breadcrumb history and return the number removed. */
+  public clearBreadcrumbs(): number;
+  public release(id: string, timestamp: string, attributes: ReleaseAttributes): void;
+  public environment(id: string, timestamp: string, attributes: EnvironmentAttributes): void;
+  public issue(id: string, timestamp: string, attributes: IssueAttributes): void;
+  /** Capture once and report queue admission. Custom issue overrides run once and return unavailable. */
+  public issueWithAdmission(id: string, timestamp: string, attributes: IssueAttributes): IssueAdmission;
+  public log(id: string, timestamp: string, attributes: LogAttributes): void;
+  public span(id: string, timestamp: string, attributes: SpanAttributes): void;
+  public action(id: string, timestamp: string, attributes: ActionAttributes): void;
+  public metric(id: string, timestamp: string, attributes: MetricAttributes): void;
+  /** Flush one queue snapshot in bounded batches while preserving concurrent captures and retry bodies. */
+  public flush(transport?: Transport): Promise<TransportResponse>;
+  /** Reject new capture, flush queued events, then close; a failed flush reopens the intact remainder. */
+  public shutdown(transport?: Transport): Promise<TransportResponse>;
+}
+
+export { LogBrewClient };

package/types/delivery.d.ts

@@ -0,0 +1,125 @@
+import type { ActionAttributes, EnvironmentAttributes, LogAttributes, MetricAttributes, ReleaseAttributes, SpanAttributes } from "./telemetry.js";
+import type { IssueAttributes } from "./issues.js";
+
+declare const DELIVERY_HEALTH_SCHEMA_VERSION = 1;
+
+/** Public event union used in preview and transport payloads. */
+type Event =
+  | { type: "release"; id: string; timestamp: string; attributes: ReleaseAttributes }
+  | { type: "environment"; id: string; timestamp: string; attributes: EnvironmentAttributes }
+  | { type: "issue"; id: string; timestamp: string; attributes: IssueAttributes }
+  | { type: "log"; id: string; timestamp: string; attributes: LogAttributes }
+  | { type: "span"; id: string; timestamp: string; attributes: SpanAttributes }
+  | { type: "action"; id: string; timestamp: string; attributes: ActionAttributes }
+  | { type: "metric"; id: string; timestamp: string; attributes: MetricAttributes };
+
+/** Drop-only event filter called after validation and before an event is queued. */
+type EventFilter = (event: Event) => boolean | void;
+
+/** Canonical compact event record exchanged with an app-owned synchronous persistence adapter. */
+type StoredEvent = {
+  event: Event;
+  serializedEvent: string;
+  eventBytes: number;
+};
+
+/** Explicit synchronous persistence seam used to recover and acknowledge queued events safely. */
+type EventStore = {
+  load(): StoredEvent[];
+  append(record: StoredEvent): void;
+  acknowledge(count: number): void;
+  /** Removes the records at ascending `load()` indexes; without it, fatal issues cannot evict queued events. */
+  remove?(indexes: number[]): void;
+  purge(): void;
+  close(): void;
+};
+
+/** Queue drop notification emitted when a bounded in-memory queue is full. */
+type DroppedEvent = {
+  reason: "event_too_large" | "evicted_for_fatal" | "queue_bytes_overflow" | "queue_overflow";
+  eventType: Event["type"];
+  eventId: string;
+  droppedEvents: number;
+};
+
+/** Stable transport response returned from flush and shutdown operations. */
+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;
+  /** Optional `code` from a 429 response body, such as `rate_limited` or `usage_limit_exceeded`. */
+  errorCode?: string;
+};
+
+/** Minimal transport interface accepted by flush and shutdown operations. */
+type Transport = {
+  send(apiKey: string, body: string): TransportResponse | Promise<TransportResponse>;
+};
+
+/** Content-free bounded delivery state with no event or sensitive transport fields. */
+type DeliveryHealthSnapshot = Readonly<{
+  /** Stable schema discriminator for JSON consumers. */
+  schemaVersion: typeof DELIVERY_HEALTH_SCHEMA_VERSION;
+  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;
+    evicted_for_fatal: number;
+    queue_bytes_overflow: number;
+    queue_overflow: number;
+  }>;
+  lastDropReason: "none" | "event_too_large" | "evicted_for_fatal" | "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;
+}>;
+
+/** Synchronous queue admission only; this result does not report delivery or retention. */
+type IssueAdmission = Readonly<
+  | { status: "admitted" }
+  | { status: "filtered" }
+  | { status: "dropped"; reason: DroppedEvent["reason"] }
+  | { status: "unavailable" }
+>;
+
+export type {
+  DeliveryHealthSnapshot,
+  DroppedEvent,
+  Event,
+  EventFilter,
+  EventStore,
+  IssueAdmission,
+  StoredEvent,
+  Transport,
+  TransportResponse
+};

package/types/issues.d.ts

@@ -0,0 +1,249 @@
+import type { Metadata, SeverityInput, TelemetryContext } from "./telemetry.js";
+import type { LogBrewClient } from "./client.js";
+import type { LogCorrelationTraceContext } from "./trace-context.js";
+
+/** Privacy-bounded generated JavaScript frame attached to an issue. */
+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 bounded function or method identity. */
+  function?: string;
+  /** Optional bounded module, package, or namespace identity. */
+  module?: string;
+  /** Whether application code classified this frame as app-owned. */
+  inApp?: boolean;
+  /** Optional release-artifact Debug ID matched to this generated file. */
+  debugId?: string;
+};
+
+/** Runtime path that captured an exception and whether it escaped that path. */
+type IssueExceptionMechanism = {
+  /** Stable low-cardinality capture mechanism, such as `react.error_boundary`. */
+  type: string;
+  /** False when the exception escaped the capture boundary. */
+  handled: boolean;
+};
+
+/** Structured exception identity attached to an issue. */
+type IssueException = {
+  /** Bounded runtime exception class or error type. */
+  type: string;
+  /** Capture mechanism when the SDK can determine it. */
+  mechanism?: IssueExceptionMechanism;
+};
+
+type IssueExceptionRelationship =
+  | "reported"
+  | "cause"
+  | "context"
+  | "aggregate_member"
+  | "suppressed";
+
+type IssueExceptionMessageState = "captured" | "truncated" | "redacted" | "not_captured";
+
+type IssueExceptionStackFramesState = "captured" | "truncated" | "not_captured";
+
+/** One parent-first runtime exception with its own message and structured stack state. */
+type IssueExceptionChainEntry = {
+  /** Contiguous zero-based node identity. */
+  id: number;
+  /** Earlier parent node. Omitted only for the reported root exception. */
+  parentId?: number;
+  relationship: IssueExceptionRelationship;
+  type: string;
+  /** Bounded message only when messageState is captured or truncated. */
+  message?: string;
+  messageState: IssueExceptionMessageState;
+  module?: string;
+  mechanism?: IssueExceptionMechanism;
+  /** This exact exception's bounded structured frames. */
+  stackFrames?: IssueStackFrame[];
+  stackFramesState: IssueExceptionStackFramesState;
+};
+
+/** At most eight parent-first runtime exceptions. */
+type IssueExceptionChain = {
+  entries: IssueExceptionChainEntry[];
+  /** True when a cycle or node cap omitted additional exceptions. */
+  truncated: boolean;
+};
+
+type IssueBreadcrumbLevel = "debug" | "info" | "warning" | "error" | "critical";
+
+type IssueBreadcrumbLevelInput = IssueBreadcrumbLevel | "trace" | "log" | "warn" | "fatal";
+
+type IssueBreadcrumbDataValue = string | number | boolean | null;
+
+/** One privacy-bounded step that happened before an issue. */
+type IssueBreadcrumb = {
+  /** RFC 3339 timestamp with an explicit timezone. */
+  timestamp: string;
+  /** Optional stable breadcrumb kind, such as `navigation` or `http`. */
+  type?: string;
+  /** Required low-cardinality source category. */
+  category: string;
+  level?: IssueBreadcrumbLevel;
+  /** Optional bounded display-safe description. */
+  message?: string;
+  /** At most eight flat primitive fields. Never include authentication material or raw request data. */
+  data?: Record<string, IssueBreadcrumbDataValue>;
+};
+
+/** Input accepted by `addBreadcrumb`; the client supplies the current timestamp when omitted. */
+type IssueBreadcrumbInput = Omit<IssueBreadcrumb, "timestamp" | "level"> & {
+  timestamp?: string;
+  level?: IssueBreadcrumbLevelInput;
+};
+
+/** App-reported code location that narrows the smallest likely fix area. */
+type IssueLikelyFixArea = {
+  component?: string;
+  module?: string;
+  function?: string;
+  /** Safe repository-relative source path. */
+  file?: string;
+  line?: number;
+  column?: number;
+  inApp?: boolean;
+};
+
+/** App-reported user impact without user identities or raw request data. */
+type IssueImpactEvidence = {
+  affectedUserSegment?: string;
+  failedAction?: string;
+  userVisibleOutcome?: string;
+};
+
+/** Explicit diagnostic evidence for cause, fix area, impact, and capture limitations. */
+type IssueDiagnosticEvidence = {
+  /** App-owned hypothesis. LogBrew presents it as reported, never proven. */
+  likelyRootCause?: string;
+  likelyFixArea?: IssueLikelyFixArea;
+  impact?: IssueImpactEvidence;
+  /** Unique bounded field names whose values were captured. */
+  capturedFields?: string[];
+  missingFields?: string[];
+  redactedFields?: string[];
+  truncatedFields?: string[];
+};
+
+type NativeStackArchitecture = "arm" | "arm64" | "arm64e" | "x86" | "x86_64";
+
+type NativeStackFrame = {
+  imageUuid: string;
+  architecture: NativeStackArchitecture;
+  instructionOffset: string;
+};
+
+/** Public issue event attributes. */
+type IssueAttributes = {
+  title: string;
+  level: SeverityInput;
+  message?: string;
+  exception?: IssueException;
+  /** Parent-first runtime exception evidence; the first node agrees with legacy exception/stackFrames. */
+  exceptionChain?: IssueExceptionChain;
+  /** Ordered privacy-bounded generated frames, capped at 32. */
+  stackFrames?: IssueStackFrame[];
+  /** Ordered native image-relative frames for exact release symbolication, capped at 32. */
+  nativeStackFrames?: NativeStackFrame[];
+  /** Oldest-to-newest issue history, capped at the most recent 64 entries. */
+  breadcrumbs?: IssueBreadcrumb[];
+  /** True when older or invalid history was omitted before capture. */
+  breadcrumbsTruncated?: boolean;
+  /** App-reported diagnostic evidence, validated and labeled separately from observed facts. */
+  evidence?: IssueDiagnosticEvidence;
+  metadata?: Metadata;
+  context?: TelemetryContext;
+};
+
+/** Options for creating privacy-bounded issue attributes from a JavaScript error. */
+type JavaScriptErrorIssueOptions = {
+  title?: string;
+  level?: SeverityInput;
+  message?: string;
+  metadata?: Metadata;
+  /** Stable low-cardinality capture mechanism. Defaults to `javascript.error`. */
+  mechanism?: string;
+  /** Whether the error was handled by the capture boundary. Defaults to true. */
+  handled?: boolean;
+  /** 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;
+  /** App-reported cause, fix-area, impact, and explicit evidence-state receipt. */
+  evidence?: IssueDiagnosticEvidence;
+  /** Include raw stack text only when the app has explicitly approved it. Defaults to false. */
+  includeErrorStack?: boolean;
+};
+
+/** Options for automatic browser breadcrumbs. Every source defaults to true. */
+type BrowserBreadcrumbOptions = {
+  console?: boolean;
+  network?: boolean;
+  navigation?: boolean;
+  /** URLs whose requests are not recorded, such as the LogBrew ingest endpoint. */
+  ignoredUrls?: string[];
+};
+
+/**
+ * Record console calls, fetch and XHR requests, and route changes in a browser window as issue
+ * breadcrumbs on the client. The wrappers only observe calls. Returns an uninstall function.
+ */
+declare function installBrowserBreadcrumbs(
+  browserWindow: unknown,
+  client: LogBrewClient,
+  options?: BrowserBreadcrumbOptions
+): () => void;
+
+/**
+ * Convert a JavaScript Error-like value into safe issue attributes with optional source-map Debug ID metadata.
+ * Parent-first cause and AggregateError evidence is bounded to the public exception-chain contract.
+ */
+declare function createIssueAttributesFromError(
+  error: unknown,
+  options?: JavaScriptErrorIssueOptions
+): IssueAttributes;
+
+export type {
+  BrowserBreadcrumbOptions,
+  IssueAttributes,
+  IssueBreadcrumb,
+  IssueBreadcrumbDataValue,
+  IssueBreadcrumbInput,
+  IssueBreadcrumbLevel,
+  IssueBreadcrumbLevelInput,
+  IssueDiagnosticEvidence,
+  IssueException,
+  IssueExceptionChain,
+  IssueExceptionChainEntry,
+  IssueExceptionMechanism,
+  IssueExceptionMessageState,
+  IssueExceptionRelationship,
+  IssueExceptionStackFramesState,
+  IssueImpactEvidence,
+  IssueLikelyFixArea,
+  IssueStackFrame,
+  JavaScriptErrorIssueOptions,
+  NativeStackArchitecture,
+  NativeStackFrame
+};
+export { createIssueAttributesFromError, installBrowserBreadcrumbs };

package/types/logging.d.ts

@@ -0,0 +1,175 @@
+import type { LogAttributes, Metadata } from "./telemetry.js";
+import type { Transport, TransportResponse } from "./delivery.js";
+import type { LogBrewClient } from "./client.js";
+import type { LogCorrelationTraceContext } from "./trace-context.js";
+
+/** Console method names supported by the opt-in console capture helper. */
+type ConsoleMethodName = "debug" | "info" | "log" | "warn" | "error";
+
+/** Minimal console-like target accepted by the opt-in console capture helper. */
+type ConsoleLike = Partial<Record<ConsoleMethodName, (...args: unknown[]) => void>>;
+
+/** Configuration for opt-in console capture. */
+type ConsoleCaptureConfig = {
+  client: LogBrewClient;
+  console?: ConsoleLike;
+  levels?: ConsoleMethodName[];
+  logger?: string;
+  metadata?: Metadata;
+  transport?: Transport;
+  flushOnCapture?: boolean;
+  includeErrorStack?: boolean;
+  timestamp?: () => string;
+  eventIdPrefix?: string;
+  onError?: (error: unknown) => void;
+};
+
+/** Handle returned by opt-in console capture installation. */
+type ConsoleCaptureHandle = {
+  flush(): Promise<TransportResponse | null>;
+  uninstall(): void;
+};
+
+/** Pino JSON log record shape accepted by the optional Pino destination helper. */
+type PinoLogRecord = Record<string, unknown> & {
+  level?: string | number;
+  time?: string | number;
+  timestamp?: string | number;
+  msg?: unknown;
+  message?: unknown;
+  err?: unknown;
+  error?: unknown;
+};
+
+/** Configuration for the dependency-free Pino destination adapter. */
+type PinoDestinationConfig = {
+  client: LogBrewClient;
+  logger?: string;
+  metadata?: Metadata;
+  traceProvider?: () => LogCorrelationTraceContext | null | undefined;
+  transport?: Transport;
+  flushOnWrite?: boolean;
+  includeErrorStack?: boolean;
+  timestamp?: () => string;
+  eventIdPrefix?: string;
+  onError?: (error: unknown) => void;
+};
+
+/** Stream-like destination returned for use as Pino's output destination. */
+type PinoDestinationHandle = {
+  write(chunk: unknown): boolean;
+  flush(): Promise<TransportResponse | null>;
+  end(): Promise<TransportResponse | null>;
+};
+
+/** Winston info object shape accepted by the optional Winston transport helper. */
+type WinstonLogInfo = Record<string, unknown> & {
+  level?: string;
+  message?: unknown;
+  timestamp?: string | number | Date;
+  time?: string | number | Date;
+  err?: unknown;
+  error?: unknown;
+  stack?: unknown;
+};
+
+/** Configuration for the dependency-free Winston transport adapter. */
+type WinstonTransportConfig = {
+  client: LogBrewClient;
+  /** Record each Winston message as an issue breadcrumb (category `log.winston`). Defaults to true. */
+  breadcrumbs?: boolean;
+  logger?: string;
+  metadata?: Metadata;
+  traceProvider?: () => LogCorrelationTraceContext | null | undefined;
+  transport?: Transport;
+  flushOnWrite?: boolean;
+  includeErrorStack?: boolean;
+  timestamp?: () => string;
+  eventIdPrefix?: string;
+  level?: string;
+  name?: string;
+  silent?: boolean;
+  handleExceptions?: boolean;
+  handleRejections?: boolean;
+  onError?: (error: unknown) => void;
+};
+
+/** Object-mode transport returned for use in a Winston logger's transports array. */
+type WinstonTransportHandle = {
+  level?: string;
+  name?: string;
+  silent?: boolean;
+  handleExceptions?: boolean;
+  handleRejections?: boolean;
+  log(info: WinstonLogInfo, callback?: () => void): void;
+  write(info: WinstonLogInfo): boolean;
+  flush(): Promise<TransportResponse | null>;
+  end(callback?: () => void): unknown;
+};
+
+/** Install explicit console capture while preserving the target console's normal output behavior. */
+declare function installLogBrewConsoleCapture(config: ConsoleCaptureConfig): ConsoleCaptureHandle;
+
+/** Convert console arguments into safe LogBrew log attributes without installing capture. */
+declare function logAttributesFromConsoleArgs(
+  method: ConsoleMethodName,
+  args: readonly unknown[],
+  options?: {
+    logger?: string;
+    metadata?: Metadata;
+    includeErrorStack?: boolean;
+  }
+): LogAttributes;
+
+/** Map a console method name to the corresponding LogBrew log level. */
+declare function logbrewLevelFromConsoleMethod(method: ConsoleMethodName): LogAttributes["level"];
+
+/** Create a dependency-free Pino destination that turns JSON log lines into queued LogBrew log events. */
+declare function createLogBrewPinoDestination(config: PinoDestinationConfig): PinoDestinationHandle;
+
+/** Convert a parsed Pino JSON log record into safe LogBrew log attributes without installing a destination. */
+declare function logAttributesFromPinoRecord(
+  record: PinoLogRecord,
+  options?: {
+    logger?: string;
+    metadata?: Metadata;
+    trace?: LogCorrelationTraceContext | null;
+    includeErrorStack?: boolean;
+  }
+): LogAttributes;
+
+/** Create a dependency-free Winston object-mode transport that queues LogBrew log events. */
+declare function createLogBrewWinstonTransport(config: WinstonTransportConfig): WinstonTransportHandle;
+
+/** Convert a Winston info object into safe LogBrew log attributes without installing a transport. */
+declare function logAttributesFromWinstonInfo(
+  info: WinstonLogInfo,
+  options?: {
+    logger?: string;
+    metadata?: Metadata;
+    trace?: LogCorrelationTraceContext | null;
+    includeErrorStack?: boolean;
+  }
+): LogAttributes;
+
+export type {
+  ConsoleCaptureConfig,
+  ConsoleCaptureHandle,
+  ConsoleLike,
+  ConsoleMethodName,
+  PinoDestinationConfig,
+  PinoDestinationHandle,
+  PinoLogRecord,
+  WinstonLogInfo,
+  WinstonTransportConfig,
+  WinstonTransportHandle
+};
+export {
+  createLogBrewPinoDestination,
+  createLogBrewWinstonTransport,
+  installLogBrewConsoleCapture,
+  logAttributesFromConsoleArgs,
+  logAttributesFromPinoRecord,
+  logAttributesFromWinstonInfo,
+  logbrewLevelFromConsoleMethod
+};