@plandek-utils/logging 0.6.0

package/LICENSE

@@ -0,0 +1,16 @@
+MIT License
+
+Copyright (c) 2024 Plandek Ltd.
+
+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,130 @@
+# @plandek-utils/logging
+
+[![npm version](https://badge.fury.io/js/%40plandek-utils%2Flogging.svg)](https://badge.fury.io/js/%40plandek-utils%2Flogging)
+[![Maintainability](https://api.codeclimate.com/v1/badges/4d6e32a1b993723d7c4f/maintainability)](https://codeclimate.com/github/plandek-utils/logging/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/4d6e32a1b993723d7c4f/test_coverage)](https://codeclimate.com/github/plandek-utils/logging/test_coverage)
+
+TypeScript utils for Logging. Includes prettifying of JSON, logging utils, and colour utils.
+
+## Installation
+
+```bash
+npm install @plandek-utils/logging
+```
+
+## Usage
+
+### Pretty JSON: `prettyJSON` and `colorPrettyJSON` or `colourPrettyJSON`
+
+```ts
+import { prettyJSON } from "@plandek-utils/logging";
+
+const obj = { name: "John", age: 30 };
+console.log(prettyJSON(obj)); // OUTPUT: {\n  "name": "John",\n  "age": 30\n}
+```
+
+```ts
+import { colorPrettyJSON } from "@plandek-utils/logging";
+
+const obj = { name: "John", age: 30 };
+console.log(colorPrettyJSON(obj));
+```
+
+output:
+
+```
+"\x1b[90m{\x1b[39m\x1b[90m\n" +
+  '  \x1b[39m\x1b[35m"name"\x1b[39m\x1b[90m:\x1b[39m\x1b[90m \x1b[39m\x1b[33m"John"\x1b[39m\x1b[90m,\x1b[39m\x1b[90m\n' +
+  '  \x1b[39m\x1b[35m"age"\x1b[39m\x1b[90m:\x1b[39m\x1b[90m \x1b[39m\x1b[32m30\x1b[39m\x1b[90m\n' +
+  "\x1b[39m\x1b[90m}\x1b[39m"
+```
+
+You can use `colorPrettyJSON` or `colourPrettyJSON` (alias).
+
+### `makeColourUtils(mode: "with-colour" | "plain"): LogColourUtils`
+
+Creates a utility object for colouring log messages using CHALK.
+
+```ts
+import { makeColourUtils } from "@plandek-utils/logging";
+
+const colorUtils = makeColourUtils("with-colour");
+console.log(colorUtils.blue("Hello"));
+
+const plainColorUtils = makeColourUtils("plain");
+console.log(plainColorUtils.blue("Hello")); // Output: Hello as is.
+```
+
+### Loggers
+
+- for real: `buildPinoLogger(level: LevelWithSilent, redactPaths?: string[]): PreparedLogger`
+- for test: `buildSinkLogger(level: LevelWithSilent, bindings?: PlainObject): PreparedLogger`
+- parse log level: `parseLogLevelOrDefault(x: string): LogLevel`
+
+Creates a Pino logger with common configuration.
+
+```ts
+import { buildPinoLogger, buildSinkLogger, parseLogLevelOrDefault } from "@plandek-utils/logging";
+
+const level = parseLogLevelOrDefault(process.env.LOG_LEVEL, "info"); // gets the log level if present, otherwise info. If the LOG_LEVEL is not a valid one it will throw.
+const logger = buildPinoLogger(level, ["req.headers.authorization"]);
+
+const testLogger = buildSinkLogger(level); // does not send any log -> useful for tests.
+
+logger.info({ req: { headers: { authorization: "Bearer token" } } }, "User logged in");
+// {"level":30,"time":"2024-10-28T11:10:58.250Z","pid":18166,"hostname":"044ce1509ebe","req":{"headers":{"authorization":"[REDACTED]"}},"msg":"User logged in"}
+
+logger.info("Hi!");
+// {"level":30,"time":"2024-10-28T11:12:48.732Z","pid":18166,"hostname":"044ce1509ebe","msg":"Hi!"}
+```
+
+### `makeLogging`
+
+```ts
+import { makeLogging } from "@plandek-utils/logging";
+
+const logger = buildPinoLogger("info");
+const logging = makeLogging({ logger, section: "api" });
+
+logging.info("User logged in", { userId: 123 });
+// {"level":30,"time":"2024-10-28T11:14:13.519Z","pid":18166,"hostname":"044ce1509ebe","logSections":["api"],"userId":123,"msg":"User logged in"}
+
+logging.withSection("database").debug("Query executed");
+// no output since `debug` is not enabled in the logger
+
+logging.withSection("database").error("Query failed");
+// {"level":50,"time":"2024-10-28T11:14:59.509Z","pid":18166,"hostname":"044ce1509ebe","logSections":["api"],"logSections":["api","database"],"msg":"Query failed"}
+```
+
+### `makeLoggingWithRecord`
+
+Same as `makeLogging`, but keeping an in-memory record of all messages (and contexts) sent. This is meant for testing
+purposes.
+
+```ts
+import { makeLoggingWithRecord, type PreparedLogger } from "@plandek-utils/logging";
+
+const logger: PreparedLogger = buildPinoLogger("info");
+const loggingWithRecords = makeLoggingWithRecord({ logger, section: "api" });
+
+loggingWithRecords.info("User logged in", { userId: 123 });
+// {"level":30,"time":"2024-10-28T11:16:49.607Z","pid":18166,"hostname":"044ce1509ebe","logSections":["api"],"userId":123,"msg":"User logged in"}
+
+console.log(loggingWithRecords.messages.info);
+// [ [ "User logged in", { userId: 123 } ] ]
+```
+
+## Development
+
+This package is developed with TypeScript and uses Vitest for testing.
+
+- `npm run build`: build the package
+- `npm test`: run tests
+- `npm run test:watch`: run tests in watch mode
+- `npm run test:coverage`: run tests with coverage
+- `npm run lint`: lint files
+- `npm run format`: format files
+
+## License
+
+MIT License - see LICENSE file

package/dist/mod.d.ts

@@ -0,0 +1,118 @@
+import type { Logger as PinoLogger } from "pino";
+import type { DeepReadonly } from "simplytyped";
+import type { PlainObject } from "@plandek-utils/plain-object";
+/**
+ * Allowed log levels for the logger.
+ */
+export declare const LOG_LEVELS: readonly ["fatal", "error", "warn", "info", "debug", "trace", "silent"];
+/**
+ * Possible log levels for preparing the pino logger.
+ */
+export type LogLevel = (typeof LOG_LEVELS)[number];
+/**
+ * Parses the given log level, or returns the default level if it's not blank. If it is an invalid level it will throw an error.
+ */
+export declare function parseLogLevelOrDefault(level: string | null | undefined, defaultLevel: LogLevel): LogLevel;
+/**
+ * Prepared pino logger, returned by `buildPinoLogger` or `buildSinkLogger`.
+ *
+ * @see buildPinoLogger
+ * @see buildSinkLogger
+ */
+export type PreparedLogger = Pick<PinoLogger, "level" | "info" | "debug" | "warn" | "error" | "bindings"> & {
+    child: (bindings: PlainObject) => PreparedLogger;
+};
+/**
+ * Prepares a Pino logger with the common configuration.
+ *
+ * @param level - The log level to use.
+ * @param redactPaths - Paths to redact from the logs. Defaults to `["req.headers.authorization", "req.headers.cookie"]`.
+ * @returns PinoLogger
+ */
+export declare function buildPinoLogger(level: LogLevel, redactPaths?: string[]): PreparedLogger;
+/**
+ * A mock logger that does nothing, holds no binding (sections).
+ */
+export declare function buildSinkLogger(level: LogLevel, givenBindings?: PlainObject): PreparedLogger;
+/**
+ * Util to serialise as JSON the given value, pretty-printed (2 spaces).
+ */
+export declare function prettyJSON(obj: unknown): string;
+/**
+ * Calls `prettyJSON` and then colourises the output.
+ */
+export declare function colourPrettyJSON(obj: unknown): string;
+/**
+ * Alias for `colourPrettyJSON`.
+ * @see colourPrettyJSON
+ */
+export declare const colorPrettyJSON: typeof colourPrettyJSON;
+/**
+ * Interface to provide colouring for logs.
+ */
+export type LogColourUtils = {
+    blue: (x: string) => string;
+    cyan: (x: string) => string;
+    gray: (x: string) => string;
+    magenta: (x: string) => string;
+    red: (x: string) => string;
+    yellow: (x: string) => string;
+};
+/**
+ * Creates a LogColourUtils object, with actual colours or not depending on the given mode.
+ *
+ * @param mode: if "with-colour", it will return a set of functions that will colour the given string. If "plain", it will return a set of functions that will return the string as is.
+ */
+export declare function makeColourUtils(mode: "with-colour" | "plain"): LogColourUtils;
+/**
+ * Logging interface. Requires a message (string) and optionally an object to log, which is required to be a Plain Object to ensure serialisation.
+ */
+type LogFn = (msg: string, obj?: DeepReadonly<PlainObject>) => void;
+/**
+ * Logging interface that provides a way to log messages with different levels. It should be configured with sections. It can return a new instance with a new section.
+ */
+export type Logging = {
+    logger: PreparedLogger;
+    info: LogFn;
+    warn: LogFn;
+    debug: LogFn;
+    error: LogFn;
+    getSections(this: Logging): string[];
+    withSection(this: Logging, section: string, context?: PlainObject): Logging;
+};
+/**
+ * Variant of the Logging interface that stores the messages that have been logged.
+ */
+export type LoggingWithRecords = Omit<Logging, "withSection"> & {
+    withSection(this: Logging, section: string, context?: PlainObject): LoggingWithRecords;
+    messages: {
+        info: Array<[string, PlainObject | null]>;
+        warn: Array<[string, PlainObject | null]>;
+        debug: Array<[string, PlainObject | null]>;
+        error: Array<[string, PlainObject | null]>;
+    };
+};
+/**
+ * Checks if the given Logging object is a LoggingWithRecords.
+ * @param obj
+ * @returns
+ */
+export declare function isLoggingWithRecords(obj: Logging): obj is LoggingWithRecords;
+/**
+ * Creates a Logging object. It requires an actual pino logger to be sent, and optionally a section and a context.
+ */
+export declare function makeLogging(opts: {
+    section?: string;
+    context?: PlainObject;
+    logger: PreparedLogger;
+}): Logging;
+/**
+ * Creates a LoggingWithRecords object. It requires an actual pino logger to be sent, and optionally a section and a context. You can pass it a "messages" record object to use or a new one will be created.
+ */
+export declare function makeLoggingWithRecord(opts: {
+    logger: PreparedLogger;
+    section?: string;
+    context?: PlainObject;
+    messages?: LoggingWithRecords["messages"];
+}): LoggingWithRecords;
+export {};

package/dist/mod.js

@@ -0,0 +1,155 @@
+// src/mod.ts
+import chalk from "chalk";
+import { colorize } from "json-colorizer";
+import { pino } from "pino";
+var LOG_LEVELS = ["fatal", "error", "warn", "info", "debug", "trace", "silent"];
+function parseLogLevelOrDefault(level, defaultLevel) {
+  if (!level)
+    return defaultLevel;
+  const lowerLevel = level.toLowerCase();
+  if (LOG_LEVELS.includes(lowerLevel)) {
+    return lowerLevel;
+  }
+  throw new Error(`Invalid log level: ${level}`);
+}
+function buildPinoLogger(level, redactPaths) {
+  const paths = redactPaths ?? ["req.headers.authorization", "req.headers.cookie"];
+  return pino({
+    level,
+    timestamp: pino.stdTimeFunctions.isoTime,
+    redact: { paths, censor: "[REDACTED]" }
+  });
+}
+function buildSinkLogger(level, givenBindings) {
+  const bindings = givenBindings ?? {};
+  return {
+    level,
+    info: () => {
+    },
+    debug: () => {
+    },
+    warn: () => {
+    },
+    error: () => {
+    },
+    child: (childBindings) => buildSinkLogger(level, { ...bindings, ...childBindings }),
+    bindings: () => bindings
+  };
+}
+function prettyJSON(obj) {
+  return JSON.stringify(obj, null, 2);
+}
+function colourPrettyJSON(obj) {
+  return colorize(prettyJSON(obj));
+}
+var colorPrettyJSON = colourPrettyJSON;
+function makeColourUtils(mode) {
+  if (mode === "with-colour") {
+    return {
+      blue: (x) => chalk.blue(x),
+      cyan: (x) => chalk.cyan(x),
+      gray: (x) => chalk.gray(x),
+      magenta: (x) => chalk.magenta(x),
+      red: (x) => chalk.red(x),
+      yellow: (x) => chalk.yellow(x)
+    };
+  }
+  if (mode === "plain") {
+    return {
+      blue: (x) => x,
+      cyan: (x) => x,
+      gray: (x) => x,
+      magenta: (x) => x,
+      red: (x) => x,
+      yellow: (x) => x
+    };
+  }
+  const _never = mode;
+  throw new Error(`Unknown mode: ${_never}`);
+}
+function isLoggingWithRecords(obj) {
+  return "messages" in obj;
+}
+function makeLogging(opts) {
+  const logger = loggerFor(opts.logger, opts.section ?? null, opts.context ?? null);
+  return {
+    logger,
+    info: (msg, obj) => logger.info(obj, msg),
+    debug: (msg, obj) => logger.debug(obj, msg),
+    warn: (msg, obj) => logger.warn(obj, msg),
+    error: (msg, obj) => logger.error(obj, msg),
+    getSections() {
+      return getSectionsFromLogger(logger);
+    },
+    withSection(section, context) {
+      if (this.getSections().includes(section))
+        return this;
+      return makeLogging({ logger: this.logger, section, context });
+    }
+  };
+}
+function makeLoggingWithRecord(opts) {
+  const logging = makeLogging(opts);
+  const messages = opts.messages ?? {
+    info: [],
+    warn: [],
+    debug: [],
+    error: []
+  };
+  function makeLogFn(logFn, key) {
+    return (msg, obj) => {
+      messages[key].push([msg, obj ?? null]);
+      return logFn(msg, obj);
+    };
+  }
+  return {
+    messages,
+    logger: logging.logger,
+    info: makeLogFn(logging.info, "info"),
+    debug: makeLogFn(logging.debug, "debug"),
+    warn: makeLogFn(logging.warn, "warn"),
+    error: makeLogFn(logging.error, "error"),
+    getSections() {
+      return logging.getSections();
+    },
+    withSection(section, context) {
+      return makeLoggingWithRecord({
+        logger: this.logger,
+        section,
+        messages,
+        context
+      });
+    }
+  };
+}
+function loggerFor(givenLogger, section, context) {
+  if (!context && (!section || loggerHasSection(givenLogger, section))) {
+    return givenLogger;
+  }
+  const childBindings = { ...context };
+  if (section) {
+    childBindings.logSections = [...getSectionsFromLogger(givenLogger), section];
+  }
+  return givenLogger.child(childBindings);
+}
+function getSectionsFromLogger(logger) {
+  return logger.bindings().logSections ?? [];
+}
+function loggerHasSection(logger, section) {
+  const sections = getSectionsFromLogger(logger);
+  return sections.includes(section);
+}
+export {
+  LOG_LEVELS,
+  buildPinoLogger,
+  buildSinkLogger,
+  colorPrettyJSON,
+  colourPrettyJSON,
+  isLoggingWithRecords,
+  makeColourUtils,
+  makeLogging,
+  makeLoggingWithRecord,
+  parseLogLevelOrDefault,
+  prettyJSON
+};
+//# sourceMappingURL=mod.js.map

package/dist/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/mod.ts"],"sourcesContent":["import chalk from \"chalk\";\nimport { colorize } from \"json-colorizer\";\nimport type { Logger as PinoLogger } from \"pino\";\nimport { pino } from \"pino\";\nimport type { DeepReadonly } from \"simplytyped\";\n\nimport type { PlainObject, PlainObjectValue } from \"@plandek-utils/plain-object\";\n\n/**\n * Allowed log levels for the logger.\n */\nexport const LOG_LEVELS = [\"fatal\", \"error\", \"warn\", \"info\", \"debug\", \"trace\", \"silent\"] as const;\n\n/**\n * Possible log levels for preparing the pino logger.\n */\nexport type LogLevel = (typeof LOG_LEVELS)[number];\n\n/**\n * Parses the given log level, or returns the default level if it's not blank. If it is an invalid level it will throw an error.\n */\nexport function parseLogLevelOrDefault(level: string | null | undefined, defaultLevel: LogLevel): LogLevel {\n  if (!level) return defaultLevel;\n\n  const lowerLevel = level.toLowerCase() as LogLevel;\n  if (LOG_LEVELS.includes(lowerLevel)) {\n    return lowerLevel;\n  }\n\n  throw new Error(`Invalid log level: ${level}`);\n}\n\n/**\n * Prepared pino logger, returned by `buildPinoLogger` or `buildSinkLogger`.\n *\n * @see buildPinoLogger\n * @see buildSinkLogger\n */\nexport type PreparedLogger = Pick<PinoLogger, \"level\" | \"info\" | \"debug\" | \"warn\" | \"error\" | \"bindings\"> & {\n  child: (bindings: PlainObject) => PreparedLogger;\n};\n\n/**\n * Prepares a Pino logger with the common configuration.\n *\n * @param level - The log level to use.\n * @param redactPaths - Paths to redact from the logs. Defaults to `[\"req.headers.authorization\", \"req.headers.cookie\"]`.\n * @returns PinoLogger\n */\nexport function buildPinoLogger(level: LogLevel, redactPaths?: string[]): PreparedLogger {\n  const paths = redactPaths ?? [\"req.headers.authorization\", \"req.headers.cookie\"];\n  return pino({\n    level,\n    timestamp: pino.stdTimeFunctions.isoTime,\n    redact: { paths, censor: \"[REDACTED]\" },\n  });\n}\n\n/**\n * A mock logger that does nothing, holds no binding (sections).\n */\nexport function buildSinkLogger(level: LogLevel, givenBindings?: PlainObject): PreparedLogger {\n  const bindings = givenBindings ?? {};\n  return {\n    level,\n    info: () => {},\n    debug: () => {},\n    warn: () => {},\n    error: () => {},\n    child: (childBindings?: PlainObject) => buildSinkLogger(level, { ...bindings, ...childBindings }),\n    bindings: () => bindings,\n  };\n}\n\n/**\n * Util to serialise as JSON the given value, pretty-printed (2 spaces).\n */\nexport function prettyJSON(obj: unknown): string {\n  return JSON.stringify(obj, null, 2);\n}\n\n/**\n * Calls `prettyJSON` and then colourises the output.\n */\nexport function colourPrettyJSON(obj: unknown): string {\n  return colorize(prettyJSON(obj));\n}\n\n/**\n * Alias for `colourPrettyJSON`.\n * @see colourPrettyJSON\n */\nexport const colorPrettyJSON = colourPrettyJSON;\n\n/**\n * Interface to provide colouring for logs.\n */\nexport type LogColourUtils = {\n  blue: (x: string) => string;\n  cyan: (x: string) => string;\n  gray: (x: string) => string;\n  magenta: (x: string) => string;\n  red: (x: string) => string;\n  yellow: (x: string) => string;\n};\n\n/**\n * Creates a LogColourUtils object, with actual colours or not depending on the given mode.\n *\n * @param mode: if \"with-colour\", it will return a set of functions that will colour the given string. If \"plain\", it will return a set of functions that will return the string as is.\n */\nexport function makeColourUtils(mode: \"with-colour\" | \"plain\"): LogColourUtils {\n  if (mode === \"with-colour\") {\n    return {\n      blue: (x: string) => chalk.blue(x),\n      cyan: (x: string) => chalk.cyan(x),\n      gray: (x: string) => chalk.gray(x),\n      magenta: (x: string) => chalk.magenta(x),\n      red: (x: string) => chalk.red(x),\n      yellow: (x: string) => chalk.yellow(x),\n    };\n  }\n\n  if (mode === \"plain\") {\n    return {\n      blue: (x: string) => x,\n      cyan: (x: string) => x,\n      gray: (x: string) => x,\n      magenta: (x: string) => x,\n      red: (x: string) => x,\n      yellow: (x: string) => x,\n    };\n  }\n\n  const _never: never = mode;\n  throw new Error(`Unknown mode: ${_never}`);\n}\n\n/**\n * Logging interface. Requires a message (string) and optionally an object to log, which is required to be a Plain Object to ensure serialisation.\n */\ntype LogFn = (msg: string, obj?: DeepReadonly<PlainObject>) => void;\n\n/**\n * Logging interface that provides a way to log messages with different levels. It should be configured with sections. It can return a new instance with a new section.\n */\nexport type Logging = {\n  logger: PreparedLogger;\n  info: LogFn;\n  warn: LogFn;\n  debug: LogFn;\n  error: LogFn;\n  getSections(this: Logging): string[];\n  withSection(this: Logging, section: string, context?: PlainObject): Logging;\n};\n\n/**\n * Variant of the Logging interface that stores the messages that have been logged.\n */\nexport type LoggingWithRecords = Omit<Logging, \"withSection\"> & {\n  withSection(this: Logging, section: string, context?: PlainObject): LoggingWithRecords;\n  messages: {\n    info: Array<[string, PlainObject | null]>;\n    warn: Array<[string, PlainObject | null]>;\n    debug: Array<[string, PlainObject | null]>;\n    error: Array<[string, PlainObject | null]>;\n  };\n};\n\n/**\n * Checks if the given Logging object is a LoggingWithRecords.\n * @param obj\n * @returns\n */\nexport function isLoggingWithRecords(obj: Logging): obj is LoggingWithRecords {\n  return \"messages\" in obj;\n}\n\n/**\n * Creates a Logging object. It requires an actual pino logger to be sent, and optionally a section and a context.\n */\nexport function makeLogging(opts: {\n  section?: string;\n  context?: PlainObject;\n  logger: PreparedLogger;\n}): Logging {\n  const logger = loggerFor(opts.logger, opts.section ?? null, opts.context ?? null);\n\n  return {\n    logger,\n    info: (msg, obj) => logger.info(obj, msg),\n    debug: (msg, obj) => logger.debug(obj, msg),\n    warn: (msg, obj) => logger.warn(obj, msg),\n    error: (msg, obj) => logger.error(obj, msg),\n    getSections(): string[] {\n      return getSectionsFromLogger(logger);\n    },\n    withSection(section, context) {\n      if (this.getSections().includes(section)) return this;\n\n      return makeLogging({ logger: this.logger, section, context });\n    },\n  };\n}\n\n/**\n * Creates a LoggingWithRecords object. It requires an actual pino logger to be sent, and optionally a section and a context. You can pass it a \"messages\" record object to use or a new one will be created.\n */\nexport function makeLoggingWithRecord(opts: {\n  logger: PreparedLogger;\n  section?: string;\n  context?: PlainObject;\n  messages?: LoggingWithRecords[\"messages\"];\n}): LoggingWithRecords {\n  const logging = makeLogging(opts);\n  const messages = opts.messages ?? {\n    info: [],\n    warn: [],\n    debug: [],\n    error: [],\n  };\n\n  function makeLogFn(logFn: LogFn, key: keyof typeof messages): LogFn {\n    return (msg, obj) => {\n      messages[key].push([msg, obj ?? null]);\n      return logFn(msg, obj);\n    };\n  }\n\n  return {\n    messages,\n    logger: logging.logger,\n    info: makeLogFn(logging.info, \"info\"),\n    debug: makeLogFn(logging.debug, \"debug\"),\n    warn: makeLogFn(logging.warn, \"warn\"),\n    error: makeLogFn(logging.error, \"error\"),\n    getSections(): string[] {\n      return logging.getSections();\n    },\n    withSection(section, context) {\n      return makeLoggingWithRecord({\n        logger: this.logger,\n        section,\n        messages,\n        context,\n      });\n    },\n  };\n}\n\n// INTERNAL\n\nfunction loggerFor(givenLogger: PreparedLogger, section: string | null, context: PlainObject | null) {\n  if (!context && (!section || loggerHasSection(givenLogger, section))) {\n    return givenLogger;\n  }\n\n  const childBindings: Record<string, PlainObjectValue> = { ...context };\n  if (section) {\n    childBindings.logSections = [...getSectionsFromLogger(givenLogger), section];\n  }\n\n  return givenLogger.child(childBindings);\n}\n\nfunction getSectionsFromLogger(logger: PreparedLogger) {\n  return logger.bindings().logSections ?? [];\n}\n\nfunction loggerHasSection(logger: PreparedLogger, section: string) {\n  const sections = getSectionsFromLogger(logger);\n  return sections.includes(section);\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@plandek-utils/logging",
+  "version": "0.6.0",
+  "description": "TypeScript utils for Logging. Includes prettifying of JSON, logging utils, and colour utils.",
+  "main": "dist/mod.js",
+  "types": "dist/mod.d.ts",
+  "type": "module",
+  "scripts": {
+    "commit": "git-cz",
+    "build": "npm run build:tsup && npm run build:dts",
+    "build:tsup": "tsup",
+    "build:dts": "echo 'emitting Declaration using tsc' && tsc --emitDeclarationOnly",
+    "fix": "npm run fix:biome",
+    "fix:biome": "biome format --write src && biome check --apply src",
+    "check": "npm run check:biome && npm run check:tsc",
+    "check:biome": "biome check --apply src",
+    "check:tsc": "tsc --noEmit",
+    "test": "vitest run --coverage",
+    "test:watch": "vitest",
+    "prepare-release": "npm run fix && npm run check && npm run test && npm run build",
+    "prepare": "husky || true"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "logging",
+    "typescript",
+    "pino",
+    "json",
+    "color",
+    "colour"
+  ],
+  "author": "Plandek Ltd.",
+  "license": "MIT",
+  "dependencies": {
+    "@plandek-utils/plain-object": "^1.1.0",
+    "chalk": "^5.3.0",
+    "json-colorizer": "^3.0.1",
+    "pino": "^9.5.0",
+    "simplytyped": "^3.3.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "1.5.3",
+    "@types/node": "20.11.0",
+    "@vitest/coverage-v8": "1.1.3",
+    "biome": "0.3.3",
+    "tsup": "8.0.1",
+    "typescript": "5.3.3",
+    "vitest": "1.1.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/plandek-utils/logging.git"
+  },
+  "bugs": {
+    "url": "https://github.com/plandek-utils/logging/issues"
+  },
+  "homepage": "https://github.com/plandek-utils/logging#readme"
+}