@trebired/logger 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+All notable changes to `@trebired/logger` will be documented here.
+
+This project follows semantic versioning once published.
+
+## 0.1.0
+
+- Added top-level `timeZone` support for saved filenames and console timestamps.
+- Kept `recorded_at` as UTC ISO 8601 for machine-readable log entries.
+- Added `console.locale` support for console timestamp display formatting.
+- Added runtime-default locale handling for console output.
+- Added configurable default log group.
+- Added console display options for timestamp, group, and metadata while always showing level and message.
+- Added publish-ready package metadata, README, MIT license, and contribution guide.
+- Added built `dist` package exports.
+- Added async queued file writing with `flush()`, `close()`, and `getStats()`.
+- Added group-based JSONL storage with ISO-style filenames.
+- Added retention cleanup, max-size rolling, optional gzip compression, redaction, serializers, sampling, request middleware, stream events, and query helpers.
+- Initial public release.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Miroslav M. and Trebired contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,368 @@
+# @trebired/logger
+
+Structured backend logging for Bun and Node.js applications that want readable console output and durable local logs without running a separate logging stack.
+
+`@trebired/logger` writes JSONL logs into group-based folders, supports custom weighted levels, queues file writes by default, and includes redaction, retention, rolling files, request-scoped loggers, and local query helpers.
+
+## Install
+
+Runtime support: Bun 1+ and Node.js 18+.
+
+```sh
+npm install @trebired/logger
+```
+
+```ts
+import { createLog } from "@trebired/logger";
+
+const log = createLog({
+  dir: "/var/log/my-app",
+  console: true,
+  quiet: true,
+});
+
+log.info("app.start", "ready", { port: 3000 });
+await log.flush();
+```
+
+## Why This Logger
+
+Most loggers either write to stdout and expect an external collector, or provide a very broad transport system. This package is intentionally opinionated around a simpler operational workflow:
+
+- structured JSONL entries
+- one directory tree per log group
+- async queued file writes by default
+- custom weighted log levels
+- local querying by group, level, day, and hour
+- built-in redaction for common sensitive fields
+- retention and file-size rolling without a database
+
+The storage layout is meant to stay human-browsable:
+
+```txt
+/var/log/my-app/
+  app/
+    start/
+      2026-05-03-13-0000-info.jsonl
+  billing/
+    invoice/
+      2026-05-03-13-0000-audit.jsonl
+```
+
+Each line is a JSON object:
+
+```json
+{"recorded_at":"2026-05-03T13:00:00.000Z","level":"info","group":"app.start","message":"ready","origin":{"source":"app","instance":null},"metadata":{"port":3000}}
+```
+
+## Core API
+
+```ts
+const log = createLog({
+  dir: "/var/log/my-app",
+  save: true,
+  console: true,
+  timeZone: "America/New_York",
+  source: "api",
+  defaultGroup: "default",
+});
+
+log.debug("app.boot", "config loaded");
+log.info("app.boot", "ready");
+log.success("job.import", "finished", { rows: 1200 });
+log.warn("http.request", "slow request", { took_ms: 842 });
+log.fail("job.import", "failed validation");
+log.error("app.runtime", "uncaught error");
+```
+
+`save` defaults to `true` when `dir` is provided. If no `dir` is provided, the logger can still emit console output and live stream events.
+
+`defaultGroup` defaults to `"default"`.
+
+`@trebired/logger` runs on both Bun and Node.js. It may print one-time package notices for runtime-specific guidance or important future package messages. For example, when it detects Node.js, it recommends Bun for best startup and file I/O performance. Pass `quiet: true` to suppress package notices:
+
+```ts
+const log = createLog({
+  quiet: true,
+});
+```
+
+When `quiet` is not `true`, the package also prints a one-time startup greeting using the same console logger style as normal entries.
+
+`timeZone` is a top-level logger option because it controls the actual local moment used for saved file names and console timestamps. It defaults to the host timezone, then falls back to `America/New_York`.
+
+Console output is configurable. `level` and `message` are always shown; timestamp, group, and metadata can be hidden. `console.locale` only controls display formatting. When `locale` is omitted or invalid, the logger passes `undefined` to `Intl.DateTimeFormat`, so JavaScript uses the runtime or system default locale:
+
+```ts
+const log = createLog({
+  timeZone: "America/New_York",
+  console: {
+    colors: true,
+    timestamp: true,
+    group: false,
+    metadata: false,
+    locale: "en-US",
+  },
+});
+```
+
+Use `timeZone` for the local hour and `console.locale` for the display style.
+
+European dot-date locales such as `cs-CZ` and `de-DE` are formatted consistently as `03.05.2026, 15:59:23`.
+
+## Full API Example
+
+```ts
+import { createLog } from "@trebired/logger";
+
+const log = createLog({
+  dir: "/var/log/my-app",
+  save: true,
+  console: {
+    enabled: true,
+    colors: true,
+    timestamp: true,
+    group: true,
+    metadata: true,
+    locale: "en-US",
+  },
+  quiet: true,
+  timeZone: "America/New_York",
+  source: "api",
+  defaultGroup: "default",
+  levels: {
+    debug: { weight: 10, label: "DEBUG", color: "#94a3b8" },
+    info: { weight: 20, label: "INFO", color: "#38bdf8" },
+    success: { weight: 25, label: "SUCCESS", color: "#22c55e", bold: true },
+    warn: { weight: 30, label: "WARN", color: "#f59e0b", stream: "stderr" },
+    fail: { weight: 40, label: "FAIL", color: "#fb7185", stream: "stderr" },
+    error: { weight: 50, label: "ERROR", color: "#ef4444", stream: "stderr", showStack: true, bold: true },
+    audit: { weight: 35, label: "AUDIT", color: "#8b5cf6" },
+    panic: { weight: 100, label: "PANIC", color: "#dc2626", stream: "stderr", showStack: true, bold: true },
+  },
+  minLevel: "debug",
+  write: {
+    mode: "async",
+    maxQueue: 10000,
+    overflow: "drop-newest",
+  },
+  retention: {
+    enabled: true,
+    maxAgeDays: 7,
+    maxFileSize: "20mb",
+    compressOldFiles: false,
+    cleanupIntervalMs: 60_000,
+  },
+  redact: {
+    includeDefaultSensitiveKeys: true,
+    paths: ["user.password", /^headers\.authorization$/i],
+    replacement: "[REDACTED]",
+  },
+  serializers: {
+    userId: (value) => `user:${String(value)}`,
+    error: (value) =>
+      value instanceof Error
+        ? { name: value.name, message: value.message, stack: value.stack }
+        : value,
+  },
+  sample: (entry) => entry.level !== "debug" || Math.random() < 0.1,
+  request: {
+    group: "http.request",
+    idHeader: "x-request-id",
+    attach: true,
+  },
+});
+
+log.info("app.start", "ready", { port: 3000 });
+log.audit("billing.invoice", "created", { invoiceId: "inv_123" });
+log.error("app.start", "failed", { reason: "missing config" });
+
+await log.flush();
+await log.close();
+```
+
+## Custom Levels
+
+Levels are weighted. `minLevel` filters out entries with lower weight.
+
+```ts
+const log = createLog({
+  levels: {
+    audit: { weight: 35, label: "AUDIT", color: "#8b5cf6" },
+    panic: { weight: 100, label: "PANIC", stream: "stderr", bold: true },
+  },
+  minLevel: "audit",
+});
+
+log.audit("billing.invoice", "created", { invoiceId: "inv_123" });
+log.panic("runtime", "unrecoverable");
+```
+
+Built-in levels are `debug`, `info`, `success`, `warn`, `fail`, and `error`. A custom level with the same name overrides the built-in config.
+
+Custom level methods are available at runtime. In TypeScript, the logger exposes dynamic level methods through an index signature, so custom names work but are not exhaustively autocompleted from the `levels` object yet.
+
+## Async Writes, Flush, and Close
+
+File writes are async queued by default.
+
+```ts
+const log = createLog({
+  dir: "/var/log/my-app",
+  write: {
+    mode: "async",
+    maxQueue: 10000,
+    overflow: "drop-newest",
+  },
+});
+
+log.info("queue.example", "queued");
+
+await log.flush();
+await log.close();
+```
+
+`getStats()` exposes write health:
+
+```ts
+const stats = log.getStats();
+// { mode, queued, written, dropped, failed, queueLength, closed }
+```
+
+For simple scripts or tests, sync writing is available:
+
+```ts
+const log = createLog({
+  dir: "./logs",
+  write: { mode: "sync" },
+});
+```
+
+## Retention and Rolling
+
+Defaults:
+
+- retention enabled
+- `maxAgeDays: 7`
+- `maxFileSize: "20mb"`
+- `compressOldFiles: false`
+
+```ts
+const log = createLog({
+  dir: "/var/log/my-app",
+  retention: {
+    maxAgeDays: 30,
+    maxFileSize: "100mb",
+    compressOldFiles: true,
+    cleanupIntervalMs: 60 * 60 * 1000,
+  },
+});
+```
+
+When a file exceeds the configured size, the logger rolls to the next sequence inside the same group and hour:
+
+```txt
+2026-05-03-13-0000-info.jsonl
+2026-05-03-13-0001-info.jsonl
+2026-05-03-13-0002-info.jsonl
+```
+
+## Redaction and Serializers
+
+Common sensitive keys are redacted by default: password, token, secret, authorization, cookie, api_key, and related variants.
+
+```ts
+const log = createLog({
+  redact: {
+    paths: ["user.ssn", /^payment\./],
+    replacement: "[hidden]",
+  },
+  serializers: {
+    userId: (value) => `user:${value}`,
+  },
+});
+
+log.info("account.update", "saved", {
+  userId: 42,
+  password: "secret",
+  user: { ssn: "123-45-6789" },
+});
+```
+
+## Scoped Loggers
+
+```ts
+const jobs = log.group("jobs.queue");
+jobs.info("started", { jobId: "job_1" });
+
+const worker = log.withScope("worker", "jobs.queue", 2);
+worker.error("failed", { jobId: "job_1" });
+```
+
+## Express-Style Middleware
+
+`requestLogger()` is compatible with Express-style middleware and attaches `req.log` by default.
+
+```ts
+app.use(log.requestLogger({
+  group: "http.request",
+  idHeader: "x-request-id",
+}));
+
+app.get("/", (req, res) => {
+  req.log.info("handled");
+  res.end("ok");
+});
+```
+
+## Query Saved Logs
+
+```ts
+import { getEntriesForDir } from "@trebired/logger";
+
+const rows = await getEntriesForDir("/var/log/my-app", {
+  level: "error",
+  groupKey: "app.runtime",
+  limit: 100,
+});
+```
+
+Logger instances also expose `getAll()`:
+
+```ts
+const recent = await log.getAll({ groupKey: "billing.invoice", limit: 50 });
+```
+
+## Sampling
+
+```ts
+const log = createLog({
+  sample: 0.1,
+});
+
+const selective = createLog({
+  sample: (entry) => entry.level === "error" || entry.group.startsWith("audit."),
+});
+```
+
+## Live Stream
+
+```ts
+import { logStream } from "@trebired/logger";
+
+logStream.on("log", (entry, context) => {
+  // context.dir is the active log directory, if one is configured
+});
+```
+
+## Development
+
+```sh
+bun install
+bun test
+bun run typecheck
+bun run build
+bun run bench
+```
+
+The npm package exports compiled files from `dist`. Publishing runs `typecheck`, tests, and `build` through `prepublishOnly`.

package/dist/constants.d.ts

@@ -0,0 +1,7 @@
+import type { LogLevelConfig } from "./types.js";
+declare const TOP_LEVEL = "top-level";
+declare const DEFAULT_LEVELS: Record<string, LogLevelConfig>;
+declare const RESERVED_METADATA_KEYS: Set<string>;
+declare const DEFAULT_SENSITIVE_KEYS: Set<string>;
+export { DEFAULT_LEVELS, DEFAULT_SENSITIVE_KEYS, RESERVED_METADATA_KEYS, TOP_LEVEL };
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,QAAA,MAAM,SAAS,cAAc,CAAC;AAE9B,QAAA,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAOjD,CAAC;AAEH,QAAA,MAAM,sBAAsB,aAqB1B,CAAC;AAEH,QAAA,MAAM,sBAAsB,aAY1B,CAAC;AAEH,OAAO,EAAE,cAAc,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,SAAS,EAAE,CAAC"}

package/dist/constants.js

@@ -0,0 +1,46 @@
+const TOP_LEVEL = "top-level";
+const DEFAULT_LEVELS = Object.freeze({
+    debug: { weight: 10, label: "DEBUG", color: "#b7c063", stream: "stdout", showStack: false, bold: false },
+    info: { weight: 20, label: "INFO", color: "#2958ea", stream: "stdout", showStack: false, bold: false },
+    success: { weight: 25, label: "SUCCESS", color: "#51b300", stream: "stdout", showStack: false, bold: false },
+    warn: { weight: 30, label: "WARN", color: "#f39c12", stream: "stderr", showStack: true, bold: false },
+    fail: { weight: 40, label: "FAIL", color: "#b30027", stream: "stderr", showStack: false, bold: false },
+    error: { weight: 50, label: "ERROR", color: "#b30000", stream: "stderr", showStack: true, bold: true },
+});
+const RESERVED_METADATA_KEYS = new Set([
+    "__recorded_at",
+    "configKey",
+    "config_key",
+    "deployment_type",
+    "group",
+    "groupKey",
+    "group_label",
+    "groupLabel",
+    "ids",
+    "instanceIndex",
+    "log_dir",
+    "log_root",
+    "meta",
+    "platform_id",
+    "recordedAt",
+    "recorded_at",
+    "source",
+    "timestamp",
+    "loggedAt",
+    "logged_at",
+]);
+const DEFAULT_SENSITIVE_KEYS = new Set([
+    "api_key",
+    "apikey",
+    "authorization",
+    "cookie",
+    "passwd",
+    "password",
+    "pwd",
+    "refresh_token",
+    "secret",
+    "token",
+    "access_token",
+]);
+export { DEFAULT_LEVELS, DEFAULT_SENSITIVE_KEYS, RESERVED_METADATA_KEYS, TOP_LEVEL };
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAEA,MAAM,SAAS,GAAG,WAAW,CAAC;AAE9B,MAAM,cAAc,GAAmC,MAAM,CAAC,MAAM,CAAC;IACnE,KAAK,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE;IACxG,IAAI,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE;IACtG,OAAO,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE;IAC5G,IAAI,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE;IACrG,IAAI,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE;IACtG,KAAK,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE;CACvG,CAAC,CAAC;AAEH,MAAM,sBAAsB,GAAG,IAAI,GAAG,CAAC;IACrC,eAAe;IACf,WAAW;IACX,YAAY;IACZ,iBAAiB;IACjB,OAAO;IACP,UAAU;IACV,aAAa;IACb,YAAY;IACZ,KAAK;IACL,eAAe;IACf,SAAS;IACT,UAAU;IACV,MAAM;IACN,aAAa;IACb,YAAY;IACZ,aAAa;IACb,QAAQ;IACR,WAAW;IACX,UAAU;IACV,WAAW;CACZ,CAAC,CAAC;AAEH,MAAM,sBAAsB,GAAG,IAAI,GAAG,CAAC;IACrC,SAAS;IACT,QAAQ;IACR,eAAe;IACf,QAAQ;IACR,QAAQ;IACR,UAAU;IACV,KAAK;IACL,eAAe;IACf,QAAQ;IACR,OAAO;IACP,cAAc;CACf,CAAC,CAAC;AAEH,OAAO,EAAE,cAAc,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,SAAS,EAAE,CAAC"}

package/dist/core/create_log.d.ts

@@ -0,0 +1,4 @@
+import type { CreateLogOptions, LogInstance } from "../types.js";
+declare function createLog(options?: CreateLogOptions): LogInstance;
+export { createLog };
+//# sourceMappingURL=create_log.d.ts.map

package/dist/core/create_log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_log.d.ts","sourceRoot":"","sources":["../../src/core/create_log.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,gBAAgB,EAAY,WAAW,EAAuD,MAAM,aAAa,CAAC;AAuEhI,iBAAS,SAAS,CAAC,OAAO,GAAE,gBAAqB,GAAG,WAAW,CAuI9D;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/core/create_log.js

@@ -0,0 +1,206 @@
+import path from "node:path";
+import { formatConsole, normalizeConsoleOptions, writeConsole } from "../format/console.js";
+import { normGroup } from "../groups.js";
+import { minLevelWeight, normalizeLevel, normalizeLevels } from "../levels/index.js";
+import { prepareMetadata } from "../metadata/process.js";
+import { buildRequestMiddleware } from "../middleware/request.js";
+import { logStream } from "../stream/index.js";
+import { getEntriesForDir } from "../storage/query.js";
+import { normalizeRetentionOptions, normalizeWriteOptions } from "../storage/options.js";
+import { FileWriter } from "../storage/write.js";
+import { normalizeTimeZone } from "../utils/datetime.js";
+import { maybeShowNodeRuntimeNotice } from "../utils/runtime.js";
+import { asObject, toString } from "../utils/values.js";
+let packageGreetingShown = false;
+function safeResolveDir(value) {
+    const raw = toString(value);
+    return raw ? path.resolve(raw) : "";
+}
+function buildOrigin(source, instance = null) {
+    const src = toString(source) || "app";
+    const inst = instance == null ? null : String(instance);
+    return {
+        source: src,
+        instance: inst || null,
+    };
+}
+function parseCallArguments(argsLike, fallbackGroup) {
+    const args = Array.isArray(argsLike) ? argsLike : Array.from(argsLike || []);
+    const hasExplicitGroup = typeof args[0] === "string" && typeof args[1] === "string";
+    return {
+        group: hasExplicitGroup ? args[0] : fallbackGroup,
+        message: hasExplicitGroup ? args[1] : String(args[0] ?? ""),
+        metadata: hasExplicitGroup ? asObject(args[2]) : asObject(args[1]),
+    };
+}
+function shouldKeepSample(entry, sample) {
+    if (sample == null)
+        return true;
+    if (typeof sample === "number") {
+        if (!Number.isFinite(sample))
+            return true;
+        if (sample <= 0)
+            return false;
+        if (sample >= 1)
+            return true;
+        return Math.random() < sample;
+    }
+    if (typeof sample === "function") {
+        try {
+            return sample(entry) === true;
+        }
+        catch {
+            return false;
+        }
+    }
+    return true;
+}
+function maybeShowPackageGreeting(quiet, consoleOptions, timeZone) {
+    if (quiet === true || packageGreetingShown)
+        return;
+    packageGreetingShown = true;
+    const entry = {
+        recorded_at: new Date().toISOString(),
+        level: "success",
+        group: "logger.loader",
+        message: "@trebired/logger initialized",
+        origin: buildOrigin("@trebired/logger"),
+    };
+    const levelConfig = {
+        weight: 25,
+        label: "SUCCESS",
+        color: "#22c55e",
+        bold: true,
+    };
+    writeConsole("stdout", formatConsole(entry, levelConfig, { ...consoleOptions, enabled: true }, timeZone));
+}
+function createLog(options = {}) {
+    const cfg = options && typeof options === "object" ? options : {};
+    maybeShowNodeRuntimeNotice(cfg.quiet);
+    const levels = normalizeLevels(cfg.levels);
+    const threshold = minLevelWeight(cfg.minLevel, levels);
+    const consoleOptions = normalizeConsoleOptions(cfg.console);
+    const timeZone = normalizeTimeZone(cfg.timeZone);
+    maybeShowPackageGreeting(cfg.quiet, consoleOptions, timeZone);
+    const defaultSource = toString(cfg.source) || "app";
+    const defaultGroup = toString(cfg.defaultGroup) || "default";
+    let loggingEnabled = true;
+    let closed = false;
+    const writer = new FileWriter({
+        dir: safeResolveDir(cfg.dir),
+        save: typeof cfg.save === "boolean" ? cfg.save : Boolean(toString(cfg.dir)),
+        write: normalizeWriteOptions(cfg.write),
+        retention: normalizeRetentionOptions(cfg.retention),
+        timeZone,
+        onError: (message) => writeConsole("stderr", message),
+    });
+    function emit(levelInput, groupInput, messageInput, metadataInput, originInput) {
+        if (!loggingEnabled || closed)
+            return;
+        const level = normalizeLevel(levelInput, levels);
+        const levelConfig = levels[level] || levels.info;
+        if (levelConfig.weight < threshold)
+            return;
+        const rawMetadata = asObject(metadataInput);
+        const recordedAt = toString(rawMetadata.__recorded_at) || new Date().toISOString();
+        const metadata = prepareMetadata(rawMetadata, cfg.serializers, cfg.redact);
+        const group = normGroup(groupInput || defaultGroup).key;
+        const message = typeof messageInput === "string" ? messageInput : String(messageInput ?? "");
+        const originSource = originInput && originInput.source ? originInput.source : defaultSource;
+        const originInstance = originInput && Object.prototype.hasOwnProperty.call(originInput, "instance") ? originInput.instance : null;
+        const entry = {
+            recorded_at: recordedAt,
+            level,
+            group,
+            message,
+            origin: buildOrigin(originSource, originInstance),
+        };
+        if (Object.keys(metadata).length)
+            entry.metadata = metadata;
+        if (!shouldKeepSample(entry, cfg.sample))
+            return;
+        if (consoleOptions.enabled)
+            writeConsole(levelConfig.stream, formatConsole(entry, levelConfig, consoleOptions, timeZone));
+        writer.write(entry);
+        try {
+            logStream.emit("log", entry, { dir: writer.getDir() });
+        }
+        catch { }
+    }
+    function logWith(level) {
+        return function levelLogger() {
+            const parsed = parseCallArguments(arguments, defaultGroup);
+            emit(level, parsed.group, parsed.message, parsed.metadata);
+        };
+    }
+    function bindGroup(groupName, originInput) {
+        const boundGroup = normGroup(groupName || defaultGroup).key;
+        const grouped = {};
+        for (const level of Object.keys(levels)) {
+            grouped[level] = (message, metadata) => emit(level, boundGroup, message, metadata, originInput);
+        }
+        grouped.child = (extraMetadata) => {
+            const extra = asObject(extraMetadata);
+            const child = {};
+            for (const level of Object.keys(levels)) {
+                child[level] = (message, metadata) => emit(level, boundGroup, message, { ...asObject(metadata), ...extra }, originInput);
+            }
+            return child;
+        };
+        return grouped;
+    }
+    const api = {
+        group(groupName) {
+            return bindGroup(groupName || defaultGroup);
+        },
+        withScope(source, groupName, instance) {
+            const originInput = {
+                source: toString(source) || defaultSource,
+                instance: instance == null ? null : String(instance),
+            };
+            return bindGroup(groupName || defaultGroup, originInput);
+        },
+        setEnabled(flag) {
+            loggingEnabled = Boolean(flag);
+        },
+        getDir() {
+            return writer.getDir();
+        },
+        setDir(nextDir) {
+            writer.setDir(safeResolveDir(nextDir));
+        },
+        requestLogger: buildRequestMiddleware(null, cfg.request),
+        logError(error, metadata, source) {
+            const meta = asObject(metadata);
+            const groupName = toString(meta.group) || defaultGroup;
+            const originSource = toString(source) || defaultSource;
+            if (error instanceof Error) {
+                emit("error", groupName, error.message, { ...meta, stack: error.stack }, { source: originSource });
+                return;
+            }
+            emit("error", groupName, String(error), meta, { source: originSource });
+        },
+        async getAll(options) {
+            await writer.flush();
+            return getEntriesForDir(writer.getDir(), options);
+        },
+        flush() {
+            return writer.flush();
+        },
+        async close() {
+            if (closed)
+                return;
+            closed = true;
+            await writer.close();
+        },
+        getStats() {
+            return writer.getStats();
+        },
+    };
+    api.requestLogger = buildRequestMiddleware(api, cfg.request);
+    for (const level of Object.keys(levels))
+        api[level] = logWith(level);
+    return api;
+}
+export { createLog };
+//# sourceMappingURL=create_log.js.map