skriva

From Old Norse skrifa, from Proto-Germanic *skrībaną, a late borrowing from Latin scrībō ("write")

About

Super-unopionionated no-black-magic logger, with zero dependencies, tailored for Typescript usage.

Like other logging libraries, multiple transports with custom logging levels are supported.

Install

npm i skriva
yarn add skriva

Examples

Define log levels

// Lower value = more important
const logLevels = {
  error: 0,
  warn: 10,
  info: 20,
  debug: 30,
};

const logger = createLogger({
  logLevels,
  // Setting to 'info' will print everything up to info (error, warn, info in this case)
  level: "info",
  /* ... */
});

const logger1 = createLogger({
  logLevels,
  // Setting to an array works like a whitelist, so in this case ONLY info will be printed
  level: ["info"],
  /* ... */
});

Basic console logger

import { createLogger } from "skriva";
// Use prebuilt console transport
import { createConsoleTransport } from "skriva-transport-console";

const logLevels = {
  error: 0,
  warn: 10,
  info: 20,
  debug: 30,
};

// createLogger has 3 types that describe what types of logs are being used
// Type 1 is the message type, aka. the data that is being written
// Type 2 is the log level type
// Type 3 is the type of the base context
const logger = createLogger<string, typeof logLevels, {}>({
  context: () => ({}),
  logLevels,
  level: "debug",
  transports: [
    // Transports receive an object (packet) containing:
    // - the message
    // - the log level
    // - the base context (merged into the object)
    {
      handler: createConsoleTransport({
        format: ({ message }) => message,
      }),
    },
  ],
});

// logger is fully type-safe, containing your custom log levels as functions
logger.info("This is a log");
// -> This is a log

Base context

const logger = createLogger({
  // Adds timestamp to every log
  // This alone won't make it show up in the message, you need to consume the context (see "More complex logger" or "Console logger with colours")
  // The base context function is executed for every received log message
  context: () => ({ timestamp: new Date() }),
  /* ... */
});

Basic JSON logger

import { createLogger } from "skriva";
// Use prebuilt console transport
import { createConsoleTransport } from "skriva-transport-console";

const logLevels = {
  error: 0,
  warn: 10,
  info: 20,
  debug: 30,
};

const logger = createLogger<string, typeof logLevels, { timestamp: Date }>({
  context: () => ({ timestamp: new Date() }),
  logLevels,
  level: "debug",
  transports: [
    {
      handler: createConsoleTransport({
        format: (packet) => JSON.stringify(packet),
      }),
    },
  ],
});

logger.info("This is a log");
// -> {"timestamp":"2022-01-18T20:27:32.389Z","message":"This is a log","level":"info"}

More complex logger

import { createLogger } from "skriva";
// Use prebuilt console transport
import { createConsoleTransport } from "skriva-transport-console";

const logLevels = {
  error: 0,
  warn: 10,
  info: 20,
  debug: 30,
};

const logger = createLogger<
  { microservice: string; text: string },
  typeof logLevels,
  { timestamp: Date }
>({
  context: () => ({ timestamp: new Date() }),
  logLevels,
  level: "debug",
  transports: [
    {
      handler: createConsoleTransport({
        format: ({ message, ...rest }) => JSON.stringify({ ...message, ...rest }),
      }),
    },
  ],
});

logger.error({
  microservice: "db",
  text: "i had an error",
});
// -> {"microservice":"db","message":"i had an error","timestamp":"2022-01-18T20:31:10.553Z","level":"error"}

Handle errors

import { createLogger } from "skriva";

const logger = createLogger({
  /* ... */
  onError: (error) => {
    console.error("Logging error");
    sendMessageToSlack(error);
  },
});

Console logger with colours

import { createLogger } from "skriva";
// Use prebuilt console transport
import { createConsoleTransport } from "skriva-transport-console";
import chalk from "chalk";

const logLevels = {
  error: 0,
  warn: 10,
  info: 20,
  debug: 30,
};

const colorize: Record<keyof typeof logLevels, Chalk> = {
  error: chalk.red,
  warn: chalk.yellow,
  info: chalk.green,
  debug: chalk.magentaBright,
};

const logger = createLogger<string, typeof logLevels, { timestamp: Date }>({
  context: () => ({ timestamp: new Date() }),
  logLevels,
  level: "debug",
  transports: [
    {
      handler: createConsoleTransport({
        format: ({ timestamp, level, message }) =>
          `${chalk.grey(timestamp.toISOString())} ${colorize[level](level)} ${message}`,
      }),
    },
  ],
});

logger.info("Hello world");
logger.debug("Another message");
logger.error("Oh no");
logger.warn("Warning");

Transports

• Console transport (recommended)
• Rotating file transport (recommended)
• Elasticsearch transport
• Append file transport (prefer using rotating file instead)

Planned

• Redis transport
• DynamoDB transport
• MongoDB transport
• SQS transport