hierarchical-area-logger 0.2.0

package/dist/index.js

@@ -0,0 +1,117 @@
+// src/Logger.ts
+import { init } from "@paralleldrive/cuid2";
+
+// src/utils.ts
+var prettyStack = (stack) => {
+  if (!stack) return [];
+  let toReplace = "";
+  const regex = /file:\/\/\/(.*)(\.wrangler|node_modules)\/.*\)/gm;
+  const m = regex.exec(stack);
+  if (m && m.length > 1) {
+    toReplace = m[1];
+  }
+  return stack.split("\n").map((line) => line.trim()).filter((line) => !line.startsWith("Error: ")).map((line) => line.replace(toReplace, "")).map((line) => line.replace("file://", ""));
+};
+var prettyError = (err) => {
+  const stack = prettyStack(err.stack);
+  const message = err.message;
+  return { message, stack };
+};
+var createRootLogEntry = ({
+  path,
+  method,
+  details,
+  eventId,
+  parentEventId,
+  withParentEventId
+}) => {
+  const url = new URL(`http://example.com${path ?? "/"}`);
+  const rootLogEntry = {
+    root: [
+      {
+        type: "info",
+        message: "Request received",
+        payload: {
+          path: `${url.pathname}${url.search}`,
+          method,
+          details,
+          eventId,
+          ...parentEventId && { parentEventId }
+        },
+        timestamp: Date.now()
+      }
+    ]
+  };
+  if (withParentEventId && !parentEventId) {
+    rootLogEntry.root.push({
+      type: "error",
+      message: "Parent event ID expected but not found",
+      timestamp: Date.now()
+    });
+  }
+  return rootLogEntry;
+};
+
+// src/Logger.ts
+var Logger = class {
+  constructor(options) {
+    this.parentEventId = options.parentEventId;
+    this.eventId = init({ fingerprint: options.details.service })();
+    this.log = createRootLogEntry({
+      path: options.path || "/",
+      method: options.method,
+      details: options.details,
+      eventId: this.eventId,
+      parentEventId: options.parentEventId,
+      withParentEventId: options.withParentEventId
+    });
+  }
+  // Area function that returns area-specific logger methods
+  getArea(name = "dummy") {
+    if (!this.log[name]) {
+      this.log[name] = [];
+    }
+    return {
+      info: (message, payload) => {
+        this.log[name].push({
+          type: "info",
+          message,
+          payload,
+          timestamp: Date.now()
+        });
+      },
+      warn: (message, payload) => {
+        this.log[name].push({
+          type: "warn",
+          message,
+          payload,
+          timestamp: Date.now()
+        });
+      },
+      error: (message, payload) => {
+        this.log[name].push({
+          type: "error",
+          message,
+          payload: payload instanceof Error ? prettyError(payload) : payload,
+          timestamp: Date.now()
+        });
+      }
+    };
+  }
+  // Public methods on main instance
+  dump() {
+    return this.log;
+  }
+  appendLogData(logData) {
+    delete logData.root;
+    this.log = { ...logData, ...this.log };
+  }
+};
+var createLogger = (options) => {
+  return new Logger(options);
+};
+export {
+  Logger,
+  createLogger
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/Logger.ts","../src/utils.ts"],"sourcesContent":["import { init } from '@paralleldrive/cuid2';\nimport { createRootLogEntry, prettyError } from './utils';\nimport { LogData, LoggerOptions, LogEntry } from './types';\n\nexport class Logger {\n  public eventId: string;\n  private log: LogData;\n  public parentEventId?: string;\n\n  constructor(options: LoggerOptions) {\n    this.parentEventId = options.parentEventId;\n    this.eventId = init({ fingerprint: options.details.service })();\n\n    this.log = createRootLogEntry({\n      path: options.path || '/',\n      method: options.method,\n      details: options.details,\n      eventId: this.eventId,\n      parentEventId: options.parentEventId,\n      withParentEventId: options.withParentEventId,\n    });\n  }\n\n  // Area function that returns area-specific logger methods\n  public getArea(name = 'dummy') {\n    if (!this.log[name]) {\n      this.log[name] = [];\n    }\n\n    return {\n      info: (message: string, payload?: LogEntry['payload']) => {\n        this.log[name]!.push({\n          type: 'info',\n          message,\n          payload,\n          timestamp: Date.now(),\n        });\n      },\n      warn: (message: string, payload?: LogEntry['payload']) => {\n        this.log[name]!.push({\n          type: 'warn',\n          message,\n          payload,\n          timestamp: Date.now(),\n        });\n      },\n      error: (message: string, payload?: LogEntry['payload'] | Error) => {\n        this.log[name]!.push({\n          type: 'error',\n          message,\n          payload: payload instanceof Error ? prettyError(payload) : payload,\n          timestamp: Date.now(),\n        });\n      },\n    };\n  }\n\n  // Public methods on main instance\n  public dump(): LogData {\n    return this.log;\n  }\n\n  public appendLogData(logData: LogData): void {\n    delete logData.root;\n    this.log = { ...logData, ...this.log };\n  }\n}\n\n// Factory function for convenience\nexport const createLogger = (options: LoggerOptions): Logger => {\n  return new Logger(options);\n};\n","import { CreateRootLogEntryOptions, LogData, RootPayload } from './types';\n\nexport const prettyStack = (stack?: string): string[] => {\n  if (!stack) return [];\n  let toReplace = '';\n\n  const regex = /file:\\/\\/\\/(.*)(\\.wrangler|node_modules)\\/.*\\)/gm;\n  const m = regex.exec(stack);\n\n  if (m && m.length > 1) {\n    toReplace = m[1];\n  }\n\n  return stack\n    .split('\\n')\n    .map((line) => line.trim())\n    .filter((line) => !line.startsWith('Error: '))\n    .map((line) => line.replace(toReplace, ''))\n    .map((line) => line.replace('file://', ''));\n};\n\nexport const prettyError = (err: Error) => {\n  const stack = prettyStack(err.stack);\n  const message = err.message;\n  return { message, stack };\n};\n\nexport const createRootLogEntry = ({\n  path,\n  method,\n  details,\n  eventId,\n  parentEventId,\n  withParentEventId,\n}: CreateRootLogEntryOptions): LogData => {\n  const url = new URL(`http://example.com${path ?? '/'}`);\n\n  const rootLogEntry: LogData = {\n    root: [\n      {\n        type: 'info',\n        message: 'Request received',\n        payload: {\n          path: `${url.pathname}${url.search}`,\n          method,\n          details,\n          eventId,\n          ...(parentEventId && { parentEventId }),\n        } as RootPayload,\n        timestamp: Date.now(),\n      },\n    ],\n  };\n\n  if (withParentEventId && !parentEventId) {\n    rootLogEntry.root.push({\n      type: 'error',\n      message: 'Parent event ID expected but not found',\n      timestamp: Date.now(),\n    });\n  }\n\n  return rootLogEntry;\n};\n"],"mappings":"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","names":[]}

package/eslint.config.js

@@ -0,0 +1,43 @@
+import js from '@eslint/js';
+import tseslint from '@typescript-eslint/eslint-plugin';
+import tsparser from '@typescript-eslint/parser';
+
+export default [
+  js.configs.recommended,
+  {
+    files: ['**/*.ts'],
+    languageOptions: {
+      parser: tsparser,
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      globals: {
+        process: 'readonly',
+        Buffer: 'readonly',
+        __dirname: 'readonly',
+        __filename: 'readonly',
+        console: 'readonly',
+        URL: 'readonly',
+        URLSearchParams: 'readonly',
+      },
+    },
+    plugins: {
+      '@typescript-eslint': tseslint,
+    },
+    rules: {
+      ...tseslint.configs.recommended.rules,
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        { argsIgnorePattern: '^_' },
+      ],
+      '@typescript-eslint/explicit-function-return-type': 'off',
+      '@typescript-eslint/no-explicit-any': 'warn',
+      '@typescript-eslint/no-empty-function': 'warn',
+      'prefer-const': 'error',
+      'no-var': 'error',
+      'no-console': 'off',
+    },
+  },
+  {
+    ignores: ['dist/', 'node_modules/', '*.js'],
+  },
+];

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "hierarchical-area-logger",
+  "version": "0.2.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "coverage": "vitest --coverage",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "lint:check": "eslint . --max-warnings=0",
+    "format": "prettier --write .",
+    "format:check": "prettier --check ."
+  },
+  "pre-commit": [
+    "lint"
+  ],
+  "author": "Roman Jankowski",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Em3ODMe/hierarchical-area-logger.git"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "description": "Hierarchical Area Logger",
+  "devDependencies": {
+    "@eslint/js": "^9.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "eslint": "^9.0.0",
+    "prettier": "^3.8.1",
+    "tsup": "^8.5.1",
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "@paralleldrive/cuid2": "^3.0.6"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "keywords": [
+    "logger",
+    "logging",
+    "typescript",
+    "nodejs"
+  ]
+}

package/src/Logger.ts

@@ -0,0 +1,72 @@
+import { init } from '@paralleldrive/cuid2';
+import { createRootLogEntry, prettyError } from './utils';
+import { LogData, LoggerOptions, LogEntry } from './types';
+
+export class Logger {
+  public eventId: string;
+  private log: LogData;
+  public parentEventId?: string;
+
+  constructor(options: LoggerOptions) {
+    this.parentEventId = options.parentEventId;
+    this.eventId = init({ fingerprint: options.details.service })();
+
+    this.log = createRootLogEntry({
+      path: options.path || '/',
+      method: options.method,
+      details: options.details,
+      eventId: this.eventId,
+      parentEventId: options.parentEventId,
+      withParentEventId: options.withParentEventId,
+    });
+  }
+
+  // Area function that returns area-specific logger methods
+  public getArea(name = 'dummy') {
+    if (!this.log[name]) {
+      this.log[name] = [];
+    }
+
+    return {
+      info: (message: string, payload?: LogEntry['payload']) => {
+        this.log[name]!.push({
+          type: 'info',
+          message,
+          payload,
+          timestamp: Date.now(),
+        });
+      },
+      warn: (message: string, payload?: LogEntry['payload']) => {
+        this.log[name]!.push({
+          type: 'warn',
+          message,
+          payload,
+          timestamp: Date.now(),
+        });
+      },
+      error: (message: string, payload?: LogEntry['payload'] | Error) => {
+        this.log[name]!.push({
+          type: 'error',
+          message,
+          payload: payload instanceof Error ? prettyError(payload) : payload,
+          timestamp: Date.now(),
+        });
+      },
+    };
+  }
+
+  // Public methods on main instance
+  public dump(): LogData {
+    return this.log;
+  }
+
+  public appendLogData(logData: LogData): void {
+    delete logData.root;
+    this.log = { ...logData, ...this.log };
+  }
+}
+
+// Factory function for convenience
+export const createLogger = (options: LoggerOptions): Logger => {
+  return new Logger(options);
+};

package/src/index.ts

@@ -0,0 +1,2 @@
+export { Logger, createLogger } from './Logger';
+export { LogData, LogEntry } from './types';

package/src/types.ts

@@ -0,0 +1,38 @@
+export type Details = { service: string } & Record<string, unknown>;
+export type Method =
+  | 'get'
+  | 'post'
+  | 'put'
+  | 'delete'
+  | 'patch'
+  | 'head'
+  | 'options'
+  | 'trace'
+  | 'connect';
+
+export type LogEntry = {
+  type: 'info' | 'warn' | 'error';
+  message: string;
+  payload?: object;
+  timestamp: number;
+};
+export type RootPayload = {
+  path?: string;
+  method?: Method;
+  eventId: string;
+  parentEventId?: string;
+  details: Details;
+};
+export type CreateRootLogEntryOptions = RootPayload & {
+  path?: string;
+  withParentEventId?: boolean;
+};
+export type LogData = Record<string, LogEntry[]>;
+
+export interface LoggerOptions {
+  details: Details;
+  path?: string;
+  parentEventId?: string;
+  withParentEventId?: boolean;
+  method?: Method;
+}

package/src/utils.ts

@@ -0,0 +1,64 @@
+import { CreateRootLogEntryOptions, LogData, RootPayload } from './types';
+
+export const prettyStack = (stack?: string): string[] => {
+  if (!stack) return [];
+  let toReplace = '';
+
+  const regex = /file:\/\/\/(.*)(\.wrangler|node_modules)\/.*\)/gm;
+  const m = regex.exec(stack);
+
+  if (m && m.length > 1) {
+    toReplace = m[1];
+  }
+
+  return stack
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => !line.startsWith('Error: '))
+    .map((line) => line.replace(toReplace, ''))
+    .map((line) => line.replace('file://', ''));
+};
+
+export const prettyError = (err: Error) => {
+  const stack = prettyStack(err.stack);
+  const message = err.message;
+  return { message, stack };
+};
+
+export const createRootLogEntry = ({
+  path,
+  method,
+  details,
+  eventId,
+  parentEventId,
+  withParentEventId,
+}: CreateRootLogEntryOptions): LogData => {
+  const url = new URL(`http://example.com${path ?? '/'}`);
+
+  const rootLogEntry: LogData = {
+    root: [
+      {
+        type: 'info',
+        message: 'Request received',
+        payload: {
+          path: `${url.pathname}${url.search}`,
+          method,
+          details,
+          eventId,
+          ...(parentEventId && { parentEventId }),
+        } as RootPayload,
+        timestamp: Date.now(),
+      },
+    ],
+  };
+
+  if (withParentEventId && !parentEventId) {
+    rootLogEntry.root.push({
+      type: 'error',
+      message: 'Parent event ID expected but not found',
+      timestamp: Date.now(),
+    });
+  }
+
+  return rootLogEntry;
+};

package/test/logger.test.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect } from 'vitest';
+import { createLogger, Logger } from '../src/Logger';
+import { Details } from '../src/types';
+
+describe('Logger', () => {
+  const mockdetails: Details = { service: 'test-service' };
+
+  it('should create a logger with details', () => {
+    const logger = createLogger({ details: mockdetails });
+    expect(logger).toBeInstanceOf(Logger);
+  });
+
+  it('should create a logger with custom options', () => {
+    const logger = createLogger({
+      details: mockdetails,
+      path: 'test-path',
+      parentEventId: 'parent-123',
+    });
+    expect(logger).toBeInstanceOf(Logger);
+  });
+
+  it('should create area logger and log messages', () => {
+    const logger = createLogger({ details: mockdetails });
+    const areaLogger = logger.getArea('test-area');
+
+    areaLogger.info('test info message');
+    areaLogger.warn('test warn message');
+    areaLogger.error('test error message');
+
+    const logs = logger.dump();
+    expect(logs['test-area']).toHaveLength(3);
+    expect(logs['test-area'][0].message).toBe('test info message');
+    expect(logs['test-area'][1].type).toBe('warn');
+    expect(logs['test-area'][2].type).toBe('error');
+  });
+
+  it('should generate event IDs correctly', () => {
+    const logger = createLogger({ details: mockdetails });
+
+    expect(logger.eventId).toBeDefined();
+    expect(typeof logger.eventId).toBe('string');
+  });
+
+  it('should handle parent event ID', () => {
+    const logger = createLogger({
+      details: mockdetails,
+      parentEventId: 'parent-123',
+    });
+
+    expect(logger.parentEventId).toBe('parent-123');
+  });
+
+  it('should append log data', () => {
+    const logger = createLogger({ details: mockdetails });
+    const logDataToAdd = {
+      area1: [
+        {
+          type: 'info' as const,
+          message: 'existing log',
+          timestamp: Date.now(),
+        },
+      ],
+    };
+
+    logger.appendLogData(logDataToAdd);
+    const logs = logger.dump();
+
+    expect(logs.area1).toBeDefined();
+    expect(logs.area1[0].message).toBe('existing log');
+  });
+
+  it('should create root log entry', () => {
+    const logger = createLogger({ details: mockdetails, path: 'test' });
+    const logs = logger.dump();
+
+    expect(logs.root).toBeDefined();
+    expect(logs.root).toHaveLength(1);
+    expect(logs.root[0].message).toBe('Request received');
+  });
+
+  it('should handle errors in error logging', () => {
+    const logger = createLogger({ details: mockdetails });
+    const areaLogger = logger.getArea('test-area');
+
+    const testError = new Error('Test error');
+    areaLogger.error('error occurred', testError);
+
+    const logs = logger.dump();
+    expect(logs['test-area'][0].payload).toHaveProperty(
+      'message',
+      'Test error'
+    );
+  });
+
+  it('should use default area name when no name provided', () => {
+    const logger = createLogger({ details: mockdetails });
+    const areaLogger = logger.getArea();
+
+    areaLogger.info('test message');
+
+    const logs = logger.dump();
+    expect(logs.dummy).toBeDefined();
+    expect(logs.dummy).toHaveLength(1);
+    expect(logs.dummy[0].message).toBe('test message');
+  });
+
+  it('should handle withParentEventId true without parentEventId', () => {
+    const logger = createLogger({
+      details: mockdetails,
+      withParentEventId: true,
+    });
+
+    const logs = logger.dump();
+    expect(logs.root).toHaveLength(2);
+    expect(logs.root[1].type).toBe('error');
+    expect(logs.root[1].message).toBe('Parent event ID expected but not found');
+  });
+});
+
+describe('createLogger', () => {
+  const mockdetails: Details = { service: 'test-service' };
+
+  it('should create a logger instance', () => {
+    const logger = createLogger({ details: mockdetails });
+    expect(logger).toBeInstanceOf(Logger);
+  });
+
+  it('should create a logger with options', () => {
+    const logger = createLogger({
+      details: mockdetails,
+      path: 'test-path',
+      parentEventId: 'parent-123',
+    });
+    expect(logger).toBeInstanceOf(Logger);
+  });
+});