@aztec/foundation 0.65.2 → 0.67.0

package/src/json-rpc/server/safe_json_rpc_server.ts

@@ -8,7 +8,7 @@ import { type AddressInfo } from 'net';
 import { format, inspect } from 'util';
 import { ZodError } from 'zod';
 
-import { type DebugLogger, createDebugLogger } from '../../log/index.js';
+import { type Logger, createLogger } from '../../log/index.js';
 import { promiseWithResolvers } from '../../promise/utils.js';
 import { type ApiSchema, type ApiSchemaFor, parseWithOptionals, schemaHasMethod } from '../../schemas/index.js';
 import { jsonStringify } from '../convert.js';
@@ -27,7 +27,7 @@ export class SafeJsonRpcServer {
     /** Health check function */
     private readonly healthCheck: StatusCheckFn = () => true,
     /** Logger */
-    private log = createDebugLogger('json-rpc:server'),
+    private log = createLogger('json-rpc:server'),
   ) {}
 
   public isHealthy(): boolean | Promise<boolean> {
@@ -170,7 +170,7 @@ interface Proxy {
  * before forwarding calls, and then converts outputs into JSON using default conversions.
  */
 export class SafeJsonProxy<T extends object = any> implements Proxy {
-  private log = createDebugLogger('json-rpc:proxy');
+  private log = createLogger('json-rpc:proxy');
   private schema: ApiSchema;
 
   constructor(private handler: T, schema: ApiSchemaFor<T>) {
@@ -233,7 +233,7 @@ export function makeHandler<T extends object>(handler: T, schema: ApiSchemaFor<T
   return [handler, schema];
 }
 
-function makeAggregateHealthcheck(namedHandlers: NamespacedApiHandlers, log?: DebugLogger): StatusCheckFn {
+function makeAggregateHealthcheck(namedHandlers: NamespacedApiHandlers, log?: Logger): StatusCheckFn {
   return async () => {
     try {
       const results = await Promise.all(
@@ -259,7 +259,7 @@ function makeAggregateHealthcheck(namedHandlers: NamespacedApiHandlers, log?: De
  */
 export function createNamespacedSafeJsonRpcServer(
   handlers: NamespacedApiHandlers,
-  log = createDebugLogger('json-rpc:server'),
+  log = createLogger('json-rpc:server'),
 ): SafeJsonRpcServer {
   const proxy = new NamespacedSafeJsonProxy(handlers);
   const healthCheck = makeAggregateHealthcheck(handlers, log);

package/src/log/index.ts

@@ -1,5 +1,5 @@
 export * from './console.js';
 export * from './debug.js';
-export * from './logger.js';
+export * from './pino-logger.js';
 export * from './log_history.js';
 export * from './log_fn.js';

package/src/log/log-filters.ts

@@ -0,0 +1,55 @@
+import { type LogLevel, LogLevels } from './log-levels.js';
+
+export type LogFilters = [string, LogLevel][];
+
+export function getLogLevelFromFilters(filters: LogFilters, module: string): LogLevel | undefined {
+  for (const [filterModule, level] of filters) {
+    if (module.startsWith(filterModule)) {
+      return level as LogLevel;
+    }
+  }
+  return undefined;
+}
+
+export function assertLogLevel(level: string): asserts level is LogLevel {
+  if (!LogLevels.includes(level as LogLevel)) {
+    throw new Error(`Invalid log level: ${level}`);
+  }
+}
+
+export function parseEnv(env: string | undefined, defaultLevel: LogLevel): [LogLevel, LogFilters] {
+  if (!env) {
+    return [defaultLevel, []];
+  }
+  const [level] = env.split(';', 1);
+  assertLogLevel(level);
+  return [level, parseFilters(env.slice(level.length + 1))];
+}
+
+export function parseFilters(definition: string | undefined): LogFilters {
+  if (!definition) {
+    return [];
+  }
+
+  const statements = definition.split(';');
+  const filters: LogFilters = [];
+  for (const statement of statements) {
+    const [level] = statement.split(':', 1);
+    const modules = statement.slice(level.length + 1);
+    if (!modules || !level) {
+      throw new Error(`Invalid log filter statement: ${statement}`);
+    }
+    const sanitizedLevel = level.trim().toLowerCase();
+    assertLogLevel(sanitizedLevel);
+    for (const module of modules.split(',')) {
+      filters.push([
+        module
+          .trim()
+          .toLowerCase()
+          .replace(/^aztec:/, ''),
+        sanitizedLevel as LogLevel | 'silent',
+      ]);
+    }
+  }
+  return filters.reverse();
+}

package/src/log/log-levels.ts

@@ -0,0 +1,3 @@
+export const LogLevels = ['silent', 'fatal', 'error', 'warn', 'info', 'verbose', 'debug', 'trace'] as const;
+
+export type LogLevel = (typeof LogLevels)[number];

package/src/log/log_fn.ts

@@ -2,4 +2,4 @@
 export type LogData = Record<string, string | number | bigint | boolean | { toString(): string } | undefined>;
 
 /** A callable logger instance. */
-export type LogFn = (msg: string, data?: LogData) => void;
+export type LogFn = (msg: string, data?: unknown) => void;

package/src/log/pino-logger.ts

@@ -0,0 +1,203 @@
+import { createColors } from 'colorette';
+import isNode from 'detect-node';
+import { pino, symbols } from 'pino';
+import { type Writable } from 'stream';
+import { inspect } from 'util';
+
+import { compactArray } from '../collection/array.js';
+import { getLogLevelFromFilters, parseEnv } from './log-filters.js';
+import { type LogLevel } from './log-levels.js';
+import { type LogData, type LogFn } from './log_fn.js';
+
+export function createLogger(module: string): Logger {
+  module = module.replace(/^aztec:/, '');
+  const pinoLogger = logger.child({ module }, { level: getLogLevelFromFilters(logFilters, module) });
+
+  // We check manually for isLevelEnabled to avoid calling processLogData unnecessarily.
+  // Note that isLevelEnabled is missing from the browser version of pino.
+  const logFn = (level: LogLevel, msg: string, data?: unknown) =>
+    isLevelEnabled(pinoLogger, level) && pinoLogger[level](processLogData((data as LogData) ?? {}), msg);
+
+  return {
+    silent: () => {},
+    // TODO(palla/log): Should we move err to data instead of the text message?
+    /** Log as fatal. Use when an error has brought down the system. */
+    fatal: (msg: string, err?: unknown, data?: unknown) => logFn('fatal', formatErr(msg, err), data),
+    /** Log as error. Use for errors in general. */
+    error: (msg: string, err?: unknown, data?: unknown) => logFn('error', formatErr(msg, err), data),
+    /** Log as warn. Use for when we stray from the happy path. */
+    warn: (msg: string, data?: unknown) => logFn('warn', msg, data),
+    /** Log as info. Use for providing an operator with info on what the system is doing. */
+    info: (msg: string, data?: unknown) => logFn('info', msg, data),
+    /** Log as verbose. Use for when we need additional insight on what a subsystem is doing. */
+    verbose: (msg: string, data?: unknown) => logFn('verbose', msg, data),
+    /** Log as debug. Use for when we need debugging info to troubleshoot an issue on a specific component. */
+    debug: (msg: string, data?: unknown) => logFn('debug', msg, data),
+    /** Log as trace. Use for when we want to denial-of-service any recipient of the logs. */
+    trace: (msg: string, data?: unknown) => logFn('trace', msg, data),
+    level: pinoLogger.level as LogLevel,
+    /** Whether the given level is enabled for this logger. */
+    isLevelEnabled: (level: LogLevel) => isLevelEnabled(pinoLogger, level),
+    /** Module name for the logger. */
+    module,
+  };
+}
+
+// Allow global hooks for processing log data.
+// Used for injecting OTEL trace_id in telemetry client.
+type LogDataHandler = (data: LogData) => LogData;
+const logDataHandlers: LogDataHandler[] = [];
+
+export function addLogDataHandler(handler: LogDataHandler): void {
+  logDataHandlers.push(handler);
+}
+
+function processLogData(data: LogData): LogData {
+  return logDataHandlers.reduce((accum, handler) => handler(accum), data);
+}
+
+// Patch isLevelEnabled missing from pino/browser.
+function isLevelEnabled(logger: pino.Logger<'verbose', boolean>, level: LogLevel): boolean {
+  return typeof logger.isLevelEnabled === 'function'
+    ? logger.isLevelEnabled(level)
+    : logger.levels.values[level] >= logger.levels.values[logger.level];
+}
+
+// Load log levels from environment variables.
+const defaultLogLevel = process.env.NODE_ENV === 'test' ? 'silent' : 'info';
+const [logLevel, logFilters] = parseEnv(process.env.LOG_LEVEL, defaultLogLevel);
+
+// Define custom logging levels for pino.
+const customLevels = { verbose: 25 };
+const pinoOpts = { customLevels, useOnlyCustomLevels: false, level: logLevel };
+
+export const levels = {
+  labels: { ...pino.levels.labels, ...Object.fromEntries(Object.entries(customLevels).map(e => e.reverse())) },
+  values: { ...pino.levels.values, ...customLevels },
+};
+
+// Transport options for pretty logging to stderr via pino-pretty.
+const useColor = true;
+const { bold, reset } = createColors({ useColor });
+export const pinoPrettyOpts = {
+  destination: 2,
+  sync: true,
+  colorize: useColor,
+  ignore: 'module,pid,hostname,trace_id,span_id,trace_flags',
+  messageFormat: `${bold('{module}')} ${reset('{msg}')}`,
+  customLevels: 'fatal:60,error:50,warn:40,info:30,verbose:25,debug:20,trace:10',
+  customColors: 'fatal:bgRed,error:red,warn:yellow,info:green,verbose:magenta,debug:blue,trace:gray',
+  minimumLevel: 'trace' as const,
+  singleLine: !['1', 'true'].includes(process.env.LOG_MULTILINE ?? ''),
+};
+
+const prettyTransport: pino.TransportTargetOptions = {
+  target: 'pino-pretty',
+  options: pinoPrettyOpts,
+  level: 'trace',
+};
+
+// Transport for vanilla stdio logging as JSON.
+const stdioTransport: pino.TransportTargetOptions = {
+  target: 'pino/file',
+  options: { destination: 2 },
+  level: 'trace',
+};
+
+// Transport for OpenTelemetry logging. While defining this here is an abstraction leakage since this
+// should live in the telemetry-client, it is necessary to ensure that the logger is initialized with
+// the correct transport. Tweaking transports of a live pino instance is tricky, and creating a new instance
+// would mean that all child loggers created before the telemetry-client is initialized would not have
+// this transport configured. Note that the target is defined as the export in the telemetry-client,
+// since pino will load this transport separately on a worker thread, to minimize disruption to the main loop.
+const otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT;
+const otelOpts = { levels };
+const otelTransport: pino.TransportTargetOptions = {
+  target: '@aztec/telemetry-client/otel-pino-stream',
+  options: otelOpts,
+  level: 'trace',
+};
+
+function makeLogger() {
+  if (!isNode) {
+    // We are on the browser.
+    return pino({ ...pinoOpts, browser: { asObject: false } });
+  } else if (process.env.JEST_WORKER_ID) {
+    // We are on jest, so we need sync logging and stream to stderr.
+    // We expect jest/setup.mjs to kick in later and replace set up a pretty logger,
+    // but if for some reason it doesn't, at least we're covered with a default logger.
+    return pino(pinoOpts, pino.destination(2));
+  } else {
+    // Regular nodejs with transports on worker thread, using pino-pretty for console logging if LOG_JSON
+    // is not set, and an optional OTLP transport if the OTLP endpoint is provided.
+    const targets: pino.TransportSingleOptions[] = compactArray([
+      ['1', 'true', 'TRUE'].includes(process.env.LOG_JSON ?? '') ? stdioTransport : prettyTransport,
+      otlpEndpoint ? otelTransport : undefined,
+    ]);
+    return pino(pinoOpts, pino.transport({ targets, levels: levels.values }));
+  }
+}
+
+const logger = makeLogger();
+
+// Log the logger configuration.
+logger.verbose(
+  {
+    module: 'logger',
+    ...logFilters.reduce((accum, [module, level]) => ({ ...accum, [`log.${module}`]: level }), {}),
+  },
+  isNode
+    ? `Logger initialized with level ${logLevel}` + (otlpEndpoint ? ` with OTLP exporter to ${otlpEndpoint}` : '')
+    : `Browser console logger initialized with level ${logLevel}`,
+);
+
+/**
+ * Overwrites the logging stream with a different destination.
+ * Used by jest/setup.mjs to set up a pretty logger.
+ */
+export function overwriteLoggingStream(stream: Writable): void {
+  (logger as any)[symbols.streamSym] = stream;
+}
+
+/**
+ * Registers an additional destination to the pino logger.
+ * Use only when working with destinations, not worker transports.
+ */
+export function registerLoggingStream(stream: Writable): void {
+  logger.verbose({ module: 'logger' }, `Registering additional logging stream`);
+  const original = (logger as any)[symbols.streamSym];
+  const destination = original
+    ? pino.multistream(
+        [
+          // Set streams to lowest logging level, and control actual logging from the parent logger
+          // otherwise streams default to info and refuse to log anything below that.
+          { level: 'trace', stream: original },
+          { level: 'trace', stream },
+        ],
+        { levels: levels.values },
+      )
+    : stream;
+  (logger as any)[symbols.streamSym] = destination;
+}
+
+/** Log function that accepts an exception object */
+type ErrorLogFn = (msg: string, err?: Error | unknown, data?: LogData) => void;
+
+/**
+ * Logger that supports multiple severity levels.
+ */
+export type Logger = { [K in LogLevel]: LogFn } & { /** Error log function */ error: ErrorLogFn } & {
+  level: LogLevel;
+  isLevelEnabled: (level: LogLevel) => boolean;
+  module: string;
+};
+
+/**
+ * Concatenates a log message and an exception.
+ * @param msg - Log message
+ * @param err - Error to log
+ * @returns A string with both the log message and the error message.
+ */
+function formatErr(msg: string, err?: Error | unknown): string {
+  return err ? `${msg}: ${inspect(err)}` : msg;
+}

package/src/queue/base_memory_queue.ts

@@ -1,11 +1,11 @@
 import { TimeoutError } from '../error/index.js';
-import { createDebugLogger } from '../log/index.js';
+import { createLogger } from '../log/index.js';
 
 export abstract class BaseMemoryQueue<T> {
   private waiting: ((item: T | null) => void)[] = [];
   private flushing = false;
 
-  constructor(private log = createDebugLogger('aztec:foundation:memory_fifo')) {}
+  constructor(private log = createLogger('foundation:memory_fifo')) {}
 
   protected abstract get items(): {
     length: number;

package/src/queue/bounded_serial_queue.ts

@@ -1,4 +1,4 @@
-import { createDebugLogger } from '../log/index.js';
+import { createLogger } from '../log/index.js';
 import { Semaphore } from './semaphore.js';
 import { SerialQueue } from './serial_queue.js';
 
@@ -10,7 +10,7 @@ export class BoundedSerialQueue {
   private readonly queue = new SerialQueue();
   private semaphore: Semaphore;
 
-  constructor(maxQueueSize: number, private log = createDebugLogger('aztec:foundation:bounded_serial_queue')) {
+  constructor(maxQueueSize: number, private log = createLogger('foundation:bounded_serial_queue')) {
     this.semaphore = new Semaphore(maxQueueSize);
   }
 

package/src/queue/fifo_memory_queue.ts

@@ -1,4 +1,4 @@
-import { type DebugLogger } from '../log/logger.js';
+import { type Logger } from '../log/index.js';
 import { BaseMemoryQueue } from './base_memory_queue.js';
 
 /**
@@ -9,7 +9,7 @@ import { BaseMemoryQueue } from './base_memory_queue.js';
 export class FifoMemoryQueue<T> extends BaseMemoryQueue<T> {
   private container = new FifoQueue<T>();
 
-  constructor(log?: DebugLogger) {
+  constructor(log?: Logger) {
     super(log);
   }
 

package/src/retry/index.ts

@@ -1,4 +1,4 @@
-import { createDebugLogger } from '../log/index.js';
+import { createLogger } from '../log/index.js';
 import { sleep } from '../sleep/index.js';
 import { Timer } from '../timer/index.js';
 
@@ -48,7 +48,7 @@ export async function retry<Result>(
   fn: () => Promise<Result>,
   name = 'Operation',
   backoff = backoffGenerator(),
-  log = createDebugLogger('aztec:foundation:retry'),
+  log = createLogger('foundation:retry'),
   failSilently = false,
 ) {
   while (true) {

package/src/schemas/utils.ts

@@ -3,13 +3,16 @@ import {
   type ParseInput,
   type ParseReturnType,
   ZodFirstPartyTypeKind,
+  type ZodObject,
   ZodOptional,
   ZodParsedType,
+  type ZodRawShape,
   type ZodType,
   type ZodTypeAny,
   z,
 } from 'zod';
 
+import { pick } from '../collection/object.js';
 import { isHex, withoutHexPrefix } from '../string/index.js';
 import { type ZodFor } from './types.js';
 
@@ -72,10 +75,10 @@ export function hexSchemaFor<TClass extends { fromString(str: string): any } | {
   string
 > {
   const stringSchema = refinement ? z.string().refine(refinement, `Not a valid instance`) : z.string();
-  const hexSchema = stringSchema.refine(isHex, 'Not a valid hex string').transform(withoutHexPrefix);
+  const hexSchema = stringSchema.refine(isHex, 'Not a valid hex string');
   return 'fromString' in klazz
     ? hexSchema.transform(klazz.fromString.bind(klazz))
-    : hexSchema.transform(str => Buffer.from(str, 'hex')).transform(klazz.fromBuffer.bind(klazz));
+    : hexSchema.transform(str => Buffer.from(withoutHexPrefix(str), 'hex')).transform(klazz.fromBuffer.bind(klazz));
 }
 
 /**
@@ -102,3 +105,8 @@ export function mapSchema<TKey, TValue>(key: ZodFor<TKey>, value: ZodFor<TValue>
 export function setSchema<T>(value: ZodFor<T>): ZodFor<Set<T>> {
   return z.array(value).transform(entries => new Set(entries));
 }
+
+/** Given an already parsed and validated object, extracts the keys defined in the given schema. Does not validate again. */
+export function pickFromSchema<T extends object, S extends ZodObject<ZodRawShape>>(obj: T, schema: S) {
+  return pick(obj, ...Object.keys(schema.shape));
+}

package/src/testing/test_data.ts

@@ -5,12 +5,21 @@ import { createConsoleLogger } from '../log/console.js';
 import { fileURLToPath } from '../url/index.js';
 
 const testData: { [key: string]: unknown[] } = {};
+let generateProtocolCircuitTestData = false;
 
 /** Returns whether test data generation is enabled */
 export function isGenerateTestDataEnabled() {
   return ['1', 'true'].includes(process.env.AZTEC_GENERATE_TEST_DATA ?? '') && typeof expect !== 'undefined';
 }
 
+/**
+ * This is separate so Prover.tomls don't get edited everytime any test is run,
+ * Only full.test updates prover tomls, then switches this off.
+ */
+export function switchGenerateProtocolCircuitTestData() {
+  generateProtocolCircuitTestData = !generateProtocolCircuitTestData;
+}
+
 /** Pushes test data with the given name, only if test data generation is enabled. */
 export function pushTestData<T>(itemName: string, data: T) {
   if (!isGenerateTestDataEnabled()) {
@@ -76,6 +85,22 @@ export function updateInlineTestData(targetFileFromRepoRoot: string, itemName: s
   logger(`Updated test data in ${targetFile} for ${itemName} to ${value}`);
 }
 
+/**
+ * Updates the sample Prover.toml files in noir-projects/noir-protocol-circuits/crates/.
+ * @remarks Requires AZTEC_GENERATE_TEST_DATA=1 & generateProtocolCircuitTestData=true to be set
+ * To re-gen, run 'AZTEC_GENERATE_TEST_DATA=1 FAKE_PROOFS=1 yarn workspace @aztec/end-to-end test full.test'
+ */
+export function updateProtocolCircuitSampleInputs(circuitName: string, value: string) {
+  if (!isGenerateTestDataEnabled() || !generateProtocolCircuitTestData) {
+    return;
+  }
+  const logger = createConsoleLogger('aztec:testing:test_data');
+  const targetFileFromRepoRoot = `noir-projects/noir-protocol-circuits/crates/${circuitName}/Prover.toml`;
+  const targetFile = getPathToFile(targetFileFromRepoRoot);
+  writeFileSync(targetFile, value);
+  logger(`Updated test data in ${targetFile} for ${circuitName}`);
+}
+
 function getPathToFile(targetFileFromRepoRoot: string) {
   const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../../../../');
   if (!existsSync(join(repoRoot, 'CODEOWNERS'))) {

package/src/transport/dispatch/create_dispatch_fn.ts

@@ -1,6 +1,6 @@
 import { format } from 'util';
 
-import { createDebugLogger } from '../../log/index.js';
+import { createLogger } from '../../log/index.js';
 
 /**
  * Represents a message object for dispatching function calls.
@@ -26,7 +26,7 @@ export interface DispatchMsg {
  * @param log - Optional logging function for debugging purposes.
  * @returns A dispatch function that accepts a DispatchMsg object and calls the target's method with provided arguments.
  */
-export function createDispatchFn(targetFn: () => any, log = createDebugLogger('aztec:foundation:dispatch')) {
+export function createDispatchFn(targetFn: () => any, log = createLogger('foundation:dispatch')) {
   return async ({ fn, args }: DispatchMsg) => {
     const target = targetFn();
     log.debug(format(`dispatching to ${target}: ${fn}`, args));

package/src/transport/transport_client.ts

@@ -1,12 +1,12 @@
 import EventEmitter from 'events';
 import { format } from 'util';
 
-import { createDebugLogger } from '../log/index.js';
+import { createLogger } from '../log/index.js';
 import { type EventMessage, type ResponseMessage, isEventMessage } from './dispatch/messages.js';
 import { type Connector } from './interface/connector.js';
 import { type Socket } from './interface/socket.js';
 
-const log = createDebugLogger('aztec:transport_client');
+const log = createLogger('foundation:transport_client');
 
 /**
  * Represents a pending request in the TransportClient.

package/src/wasm/wasm_module.ts

@@ -59,7 +59,7 @@ export class WasmModule implements IWasmModule {
   constructor(
     private module: WebAssembly.Module | Buffer,
     private importFn: (module: WasmModule) => any,
-    loggerName = 'aztec:wasm',
+    loggerName = 'wasm',
   ) {
     this.debug = createDebugOnlyLogger(loggerName);
     this.mutexQ.put(true);

package/src/worker/worker_pool.ts

@@ -1,7 +1,7 @@
-import { createDebugLogger } from '../log/index.js';
+import { createLogger } from '../log/index.js';
 import { type WasmWorker } from './wasm_worker.js';
 
-const log = createDebugLogger('bb:worker_pool');
+const log = createLogger('foundation:worker_pool');
 
 /**
  * Type of a worker factory.

package/dest/log/logger.d.ts

@@ -1,57 +0,0 @@
-import { type LogData, type LogFn } from './log_fn.js';
-declare const LogLevels: readonly ["silent", "error", "warn", "info", "verbose", "debug"];
-/**
- * A valid log severity level.
- */
-export type LogLevel = (typeof LogLevels)[number];
-export declare let currentLevel: "silent" | "error" | "warn" | "info" | "verbose" | "debug";
-/** Log function that accepts an exception object */
-type ErrorLogFn = (msg: string, err?: Error | unknown, data?: LogData) => void;
-/**
- * Logger that supports multiple severity levels.
- */
-export type Logger = {
-    [K in LogLevel]: LogFn;
-} & {
-    error: ErrorLogFn;
-};
-/**
- * Logger that supports multiple severity levels and can be called directly to issue a debug statement.
- * Intended as a drop-in replacement for the debug module.
- */
-export type DebugLogger = Logger;
-/**
- * Creates a new DebugLogger for the current module, defaulting to the LOG_LEVEL env var.
- * If DEBUG="[module]" env is set, will enable debug logging if the module matches.
- * Uses npm debug for debug level and console.error for other levels.
- * @param name - Name of the module.
- * @param fixedLogData - Additional data to include in the log message.
- * @usage createDebugLogger('aztec:validator');
- * // will always add the validator address to the log labels
- * @returns A debug logger.
- */
-export declare function createDebugLogger(name: string): DebugLogger;
-/**
- * A function to create a logger that automatically includes fixed data in each log entry.
- * @param debugLogger - The base DebugLogger instance to which we attach fixed log data.
- * @param fixedLogData - The data to be included in every log entry.
- * @returns A DebugLogger with log level methods (error, warn, info, verbose, debug) that
- * automatically attach `fixedLogData` to every log message.
- */
-export declare function attachedFixedDataToLogger(debugLogger: DebugLogger, fixedLogData: LogData): DebugLogger;
-/** A callback to capture all logs. */
-export type LogHandler = (level: LogLevel, namespace: string, msg: string, data?: LogData) => void;
-/**
- * Registers a callback for all logs, whether they are emitted in the current log level or not.
- * @param handler - Callback to be called on every log.
- */
-export declare function onLog(handler: LogHandler): void;
-/** Overrides current log level. */
-export declare function setLevel(level: LogLevel): void;
-/**
- * Formats structured log data as a string for console output.
- * @param data - Optional log data.
- */
-export declare function fmtLogData(data?: LogData): string;
-export {};
-//# sourceMappingURL=logger.d.ts.map

package/dest/log/logger.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/log/logger.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,aAAa,CAAC;AAEvD,QAAA,MAAM,SAAS,kEAAmE,CAAC;AAEnF;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAelD,eAAO,IAAI,YAAY,4DAAgB,CAAC;AAwBxC,oDAAoD;AACpD,KAAK,UAAU,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;AAE/E;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG;KAAG,CAAC,IAAI,QAAQ,GAAG,KAAK;CAAE,GAAG;IAA4B,KAAK,EAAE,UAAU,CAAA;CAAE,CAAC;AAElG;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC;AAEjC;;;;;;;;;GASG;AAEH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAqB3D;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,OAAO,GAAG,WAAW,CActG;AAED,sCAAsC;AACtC,MAAM,MAAM,UAAU,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;AAInG;;;GAGG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,UAAU,QAExC;AAED,mCAAmC;AACnC,wBAAgB,QAAQ,CAAC,KAAK,EAAE,QAAQ,QAEvC;AAkCD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,CAIjD"}