@onebun/logger 0.1.0

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@onebun/logger",
+  "version": "0.1.0",
+  "description": "Logger package for OneBun framework",
+  "license": "LGPL-3.0",
+  "author": "RemRyahirev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RemRyahirev/onebun.git",
+    "directory": "packages/logger"
+  },
+  "bugs": {
+    "url": "https://github.com/RemRyahirev/onebun/issues"
+  },
+  "homepage": "https://github.com/RemRyahirev/onebun/tree/master/packages/logger#readme",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "main": "src/index.ts",
+  "module": "src/index.ts",
+  "types": "src/index.ts",
+  "scripts": {
+    "test": "bun test"
+  },
+  "dependencies": {
+    "effect": "^3.13.10"
+  },
+  "devDependencies": {
+    "bun-types": "1.2.2"
+  },
+  "engines": {
+    "bun": "1.2.2"
+  }
+}

package/src/formatter.ts

@@ -0,0 +1,257 @@
+import {
+  type LogEntry,
+  type LogFormatter,
+  LogLevel,
+} from './types';
+
+/**
+ * Maximum recursion depth for object formatting
+ */
+const MAX_OBJECT_DEPTH = 3;
+
+/**
+ * Standard width for level names alignment in console output
+ */
+const LEVEL_NAME_WIDTH = 7;
+
+/**
+ * Number of characters to display from trace/span IDs for brevity
+ */
+const TRACE_ID_DISPLAY_LENGTH = 8;
+
+/**
+ * Colors for console output
+ */
+const COLORS: Record<string, string> = {
+  [LogLevel.Trace]: '\x1b[90m', // Gray
+  [LogLevel.Debug]: '\x1b[36m', // Cyan
+  [LogLevel.Info]: '\x1b[32m', // Green
+  [LogLevel.Warning]: '\x1b[33m', // Yellow
+  [LogLevel.Error]: '\x1b[31m', // Red
+  [LogLevel.Fatal]: '\x1b[35m', // Magenta
+  RESET: '\x1b[0m',
+  DIM: '\x1b[2m',
+  BRIGHT: '\x1b[1m',
+};
+
+/**
+ * Format a value for pretty output
+ */
+function formatValue(value: unknown, depth = 0): string {
+  if (value === null) {
+    return '\x1b[90mnull\x1b[0m';
+  }
+  if (value === undefined) {
+    return '\x1b[90mundefined\x1b[0m';
+  }
+
+  if (typeof value === 'string') {
+    return `\x1b[32m"${value}"\x1b[0m`;
+  }
+
+  if (typeof value === 'number') {
+    return `\x1b[33m${value}\x1b[0m`;
+  }
+
+  if (typeof value === 'boolean') {
+    return `\x1b[35m${value}\x1b[0m`;
+  }
+
+  if (value instanceof Date) {
+    return `\x1b[36m${value.toISOString()}\x1b[0m`;
+  }
+
+  if (value instanceof Error) {
+    return `\x1b[31m${value.name}: ${value.message}\x1b[0m`;
+  }
+
+  if (Array.isArray(value)) {
+    if (depth > MAX_OBJECT_DEPTH) {
+      return '\x1b[90m[Array]\x1b[0m';
+    }
+
+    const items = value.map((item) => formatValue(item, depth + 1));
+    if (items.length === 0) {
+      return '\x1b[90m[]\x1b[0m';
+    }
+
+    const indent = '  '.repeat(depth + 1);
+    const closeIndent = '  '.repeat(depth);
+
+    return `\x1b[90m[\x1b[0m\n${indent}${items.join(`,\n${indent}`)}\n${closeIndent}\x1b[90m]\x1b[0m`;
+  }
+
+  if (typeof value === 'object') {
+    if (depth > MAX_OBJECT_DEPTH) {
+      return '\x1b[90m[Object]\x1b[0m';
+    }
+
+    const entries = Object.entries(value as Record<string, unknown>);
+    if (entries.length === 0) {
+      return '\x1b[90m{}\x1b[0m';
+    }
+
+    const indent = '  '.repeat(depth + 1);
+    const closeIndent = '  '.repeat(depth);
+
+    const formattedEntries = entries.map(([key, val]) => {
+      const formattedKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)
+        ? `\x1b[34m${key}\x1b[0m`
+        : `\x1b[32m"${key}"\x1b[0m`;
+
+      return `${formattedKey}: ${formatValue(val, depth + 1)}`;
+    });
+
+    return `\x1b[90m{\x1b[0m\n${indent}${formattedEntries.join(`,\n${indent}`)}\n${closeIndent}\x1b[90m}\x1b[0m`;
+  }
+
+  if (typeof value === 'function') {
+    return `\x1b[36m[Function: ${value.name || 'anonymous'}]\x1b[0m`;
+  }
+
+  return String(value);
+}
+
+/**
+ * Pretty console formatter with colors
+ */
+export class PrettyFormatter implements LogFormatter {
+  format(entry: LogEntry): string {
+    const time = entry.timestamp.toISOString();
+
+    const level = this.getLevelName(entry.level).padEnd(LEVEL_NAME_WIDTH);
+    const color = COLORS[entry.level.toString()] || '';
+    const reset = COLORS.RESET;
+
+    // Add trace information if available
+    const traceInfo = entry.trace
+      ? ` [trace:${entry.trace.traceId.slice(-TRACE_ID_DISPLAY_LENGTH)} span:${entry.trace.spanId.slice(-TRACE_ID_DISPLAY_LENGTH)}]`
+      : '';
+
+    // Extract className from context for main log line
+    let className = '';
+    let contextWithoutClassName: Record<string, unknown> = {};
+
+    if (entry.context) {
+      const { className: extractedClassName, ...restContext } = entry.context;
+      if (extractedClassName && typeof extractedClassName === 'string') {
+        className = ` [${extractedClassName}]`;
+      }
+      contextWithoutClassName = restContext;
+    }
+
+    let message = `${color}${time} [${level}]${reset}${traceInfo}${className} ${entry.message}`;
+
+    // Handle additional data first (this is the main new functionality)
+    if (contextWithoutClassName.__additionalData) {
+      const additionalData = contextWithoutClassName.__additionalData as unknown[];
+      if (additionalData.length > 0) {
+        const formattedData = additionalData.map((data) => formatValue(data)).join(' ');
+        message += ` ${formattedData}`;
+      }
+      // Remove __additionalData from context since we've processed it
+      delete contextWithoutClassName.__additionalData;
+    }
+
+    // Handle regular context (excluding special fields and className)
+    if (Object.keys(contextWithoutClassName).length > 0) {
+      const contextWithoutSpecialFields = { ...contextWithoutClassName };
+      delete contextWithoutSpecialFields.SHOW_CONTEXT;
+
+      if (Object.keys(contextWithoutSpecialFields).length > 0) {
+        message += `\n${COLORS.DIM}Context:${COLORS.RESET} ${formatValue(contextWithoutSpecialFields)}`;
+      }
+    }
+
+    if (entry.error) {
+      message += `\n${COLORS[LogLevel.Error]}Error:${COLORS.RESET} ${entry.error.stack || entry.error.message}`;
+    }
+
+    return message;
+  }
+
+  private getLevelName(level: LogLevel): string {
+    switch (level) {
+      case LogLevel.Trace:
+        return 'TRACE';
+      case LogLevel.Debug:
+        return 'DEBUG';
+      case LogLevel.Info:
+        return 'INFO';
+      case LogLevel.Warning:
+        return 'WARN';
+      case LogLevel.Error:
+        return 'ERROR';
+      case LogLevel.Fatal:
+        return 'FATAL';
+      default:
+        return 'UNKNOWN';
+    }
+  }
+}
+
+/**
+ * JSON formatter for structured logging
+ */
+export class JsonFormatter implements LogFormatter {
+  format(entry: LogEntry): string {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const logData: any = {
+      timestamp: entry.timestamp.toISOString(),
+      level: this.getLevelName(entry.level),
+      message: entry.message,
+    };
+
+    if (entry.trace) {
+      logData.trace = {
+        traceId: entry.trace.traceId,
+        spanId: entry.trace.spanId,
+        ...(entry.trace.parentSpanId ? { parentSpanId: entry.trace.parentSpanId } : {}),
+      };
+    }
+
+    if (entry.context) {
+      const contextData = { ...entry.context };
+
+      // Extract additional data if present
+      if (contextData.__additionalData) {
+        logData.additionalData = contextData.__additionalData;
+        delete contextData.__additionalData;
+      }
+
+      // Add remaining context
+      if (Object.keys(contextData).length > 0) {
+        logData.context = contextData;
+      }
+    }
+
+    if (entry.error) {
+      logData.error = {
+        message: entry.error.message,
+        stack: entry.error.stack,
+        name: entry.error.name,
+      };
+    }
+
+    return JSON.stringify(logData);
+  }
+
+  private getLevelName(level: LogLevel): string {
+    switch (level) {
+      case LogLevel.Trace:
+        return 'trace';
+      case LogLevel.Debug:
+        return 'debug';
+      case LogLevel.Info:
+        return 'info';
+      case LogLevel.Warning:
+        return 'warn';
+      case LogLevel.Error:
+        return 'error';
+      case LogLevel.Fatal:
+        return 'fatal';
+      default:
+        return 'unknown';
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export {
+  createSyncLogger,
+  type Logger,
+  LoggerService,
+  makeLogger,
+  type SyncLogger,
+} from './logger';

package/src/logger.test.ts

@@ -0,0 +1,588 @@
+import {
+  describe,
+  it,
+  expect,
+  spyOn,
+  beforeEach,
+  afterEach,
+} from 'bun:test';
+import { Effect } from 'effect';
+
+import { JsonFormatter, PrettyFormatter } from './formatter';
+import {
+  LoggerService,
+  createSyncLogger,
+  makeDevLogger,
+} from './logger';
+import { makeLogger } from './logger';
+import { ConsoleTransport } from './transport';
+import { LogLevel, type LogEntry } from './types';
+
+
+describe('PrettyFormatter', () => {
+  it('formats basic info with color, level and message', () => {
+    const formatter = new PrettyFormatter();
+    const entry: LogEntry = {
+      level: LogLevel.Info,
+      message: 'Hello',
+      timestamp: new Date('2025-01-01T00:00:00.000Z'),
+    };
+    const out = formatter.format(entry);
+    expect(out).toContain('[INFO   ]');
+    expect(out).toContain('Hello');
+  });
+
+  it('includes className in brackets and additionalData inline', () => {
+    const formatter = new PrettyFormatter();
+    const entry: LogEntry = {
+      level: LogLevel.Debug,
+      message: 'Data',
+      timestamp: new Date('2025-01-01T00:00:00.000Z'),
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      context: { className: 'Test', __additionalData: ['a', 1, true] },
+    };
+    const out = formatter.format(entry);
+    expect(out).toContain('[Test]');
+    expect(out).toContain('"a"');
+    expect(out).toContain('1');
+    expect(out).toContain('true');
+  });
+
+  it('prints context object pretty when present (excluding special fields)', () => {
+    const formatter = new PrettyFormatter();
+    const entry: LogEntry = {
+      level: LogLevel.Warning,
+      message: 'Warn',
+      timestamp: new Date('2025-01-01T00:00:00.000Z'),
+      context: { a: 1, SHOW_CONTEXT: true },
+    };
+    const out = formatter.format(entry);
+    expect(out).toContain('Context:');
+    expect(out).toContain('a');
+    expect(out).not.toContain('SHOW_CONTEXT');
+  });
+
+  it('includes error stack if error present', () => {
+    const formatter = new PrettyFormatter();
+    const error = new Error('Boom');
+    const entry: LogEntry = {
+      level: LogLevel.Error,
+      message: 'Err',
+      timestamp: new Date('2025-01-01T00:00:00.000Z'),
+      error,
+    };
+    const out = formatter.format(entry);
+    expect(out).toContain('Error:');
+    expect(out).toContain('Boom');
+  });
+
+  it('adds trace info with last 8 chars', () => {
+    const formatter = new PrettyFormatter();
+    const entry: LogEntry = {
+      level: LogLevel.Info,
+      message: 'Traced',
+      timestamp: new Date('2025-01-01T00:00:00.000Z'),
+      trace: { traceId: '1234567890abcdef', spanId: 'abcdef1234567890' },
+    } as LogEntry;
+    const out = formatter.format(entry);
+    expect(out).toContain('trace:90abcdef');
+    expect(out).toContain('span:34567890');
+  });
+});
+
+describe('JsonFormatter', () => {
+  it('produces structured json', () => {
+    const formatter = new JsonFormatter();
+    const entry: LogEntry = {
+      level: LogLevel.Info,
+      message: 'Hi',
+      timestamp: new Date('2025-01-01T00:00:00.000Z'),
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      context: { x: 1, __additionalData: [2, 'b'] },
+      error: new Error('E'),
+      trace: { traceId: 't', spanId: 's', parentSpanId: 'p' },
+    };
+    const obj = JSON.parse(formatter.format(entry));
+    expect(obj.level).toBe('info');
+    expect(obj.message).toBe('Hi');
+    expect(obj.context).toEqual({ x: 1 });
+    expect(obj.additionalData).toEqual([2, 'b']);
+    expect(obj.error.message).toBe('E');
+    expect(obj.trace.traceId).toBe('t');
+    expect(obj.trace.parentSpanId).toBe('p');
+  });
+});
+
+describe('ConsoleTransport', () => {
+  const transport = new ConsoleTransport();
+  let logSpy: ReturnType<typeof spyOn>;
+  let infoSpy: ReturnType<typeof spyOn>;
+  let warnSpy: ReturnType<typeof spyOn>;
+  let errorSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    logSpy = spyOn(console, 'log').mockImplementation(() => undefined);
+    infoSpy = spyOn(console, 'info').mockImplementation(() => undefined);
+    warnSpy = spyOn(console, 'warn').mockImplementation(() => undefined);
+    errorSpy = spyOn(console, 'error').mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    logSpy.mockRestore();
+    infoSpy.mockRestore();
+    warnSpy.mockRestore();
+    errorSpy.mockRestore();
+  });
+
+  const ts = new Date();
+  const base: Omit<LogEntry, 'level'|'message'> = { timestamp: ts };
+
+  it('routes info to console.info', () => {
+    Effect.runSync(transport.log('x', { ...base, level: LogLevel.Info, message: 'm' }));
+    expect(infoSpy).toHaveBeenCalled();
+  });
+
+  it('routes warn to console.warn', () => {
+    Effect.runSync(transport.log('x', { ...base, level: LogLevel.Warning, message: 'm' }));
+    expect(warnSpy).toHaveBeenCalled();
+  });
+
+  it('routes error/fatal to console.error and others to console.log', () => {
+    Effect.runSync(transport.log('x', { ...base, level: LogLevel.Error, message: 'm' }));
+    expect(errorSpy).toHaveBeenCalled();
+    Effect.runSync(transport.log('x', { ...base, level: LogLevel.Fatal, message: 'm' }));
+    expect(errorSpy).toHaveBeenCalledTimes(2);
+    Effect.runSync(transport.log('x', { ...base, level: LogLevel.Debug, message: 'm' }));
+    expect(logSpy).toHaveBeenCalled();
+  });
+
+  it('routes trace to console.log', () => {
+    Effect.runSync(transport.log('trace message', { ...base, level: LogLevel.Trace, message: 'trace' }));
+    expect(logSpy).toHaveBeenCalledWith('trace message');
+  });
+
+  it('should create ConsoleTransport instance', () => {
+    const newTransport = new ConsoleTransport();
+    expect(newTransport).toBeInstanceOf(ConsoleTransport);
+    expect(typeof newTransport.log).toBe('function');
+  });
+
+  it('should create ConsoleTransport with implicit constructor', () => {
+    // Test explicit constructor call to improve coverage
+    const transport1 = new ConsoleTransport();
+    const transport2 = new ConsoleTransport();
+    
+    expect(transport1).toBeInstanceOf(ConsoleTransport);
+    expect(transport2).toBeInstanceOf(ConsoleTransport);
+    expect(transport1).not.toBe(transport2); // Different instances
+  });
+
+  it('should handle unknown log level', () => {
+    // Test the default case in switch statement
+    const unknownLevel = 999 as LogLevel;
+    Effect.runSync(transport.log('unknown level', { ...base, level: unknownLevel, message: 'test' }));
+    expect(logSpy).toHaveBeenCalledWith('unknown level');
+  });
+});
+
+describe('Logger + SyncLogger basic flow', () => {
+  it('filters by minLevel and merges contexts and additional data', () => {
+    // Create a minimal logger by constructing our own transport that captures output
+    const outputs: string[] = [];
+    const transport = new (class extends ConsoleTransport {
+      override log(formattedEntry: string, entry: LogEntry) {
+        return Effect.sync(() => {
+          outputs.push(formattedEntry + '|' + entry.level);
+        });
+      }
+    })();
+
+    const loggerLayer = makeDevLogger({ minLevel: LogLevel.Info, transport });
+
+    // Extract the underlying logger by creating a small helper service instance
+    // We cannot easily read from Layer in tests, so we re-create SyncLogger through
+    // the public API using LoggerService tag and Effect runtime.
+
+    // Build a ad-hoc logger effect from the layer and run logging through Effect directly
+    const loggerEffect = Effect.flatMap(LoggerService, (logger) => Effect.succeed(logger));
+    const provided = Effect.provide(loggerEffect, loggerLayer);
+    const logger = Effect.runSync(provided);
+
+    // Create sync wrapper for easier calls
+    const sync = createSyncLogger(logger);
+
+    sync.debug('dropped'); // below Info, should be filtered
+    sync.info('hello', { a: 1 }, 'xtra');
+
+    expect(outputs.length).toBe(1);
+    expect(outputs[0]).toContain('hello');
+    expect(outputs[0]).toContain('Context');
+  });
+
+  it('child adds context and uses global trace context in SyncLogger', () => {
+    const outputs: LogEntry[] = [];
+    const transport = new (class extends ConsoleTransport {
+      override log(_formattedEntry: string, entry: LogEntry) {
+        return Effect.sync(() => {
+          outputs.push(entry);
+        });
+      }
+    })();
+
+    const layer = makeDevLogger({ transport });
+    const logger = Effect.runSync(Effect.provide(Effect.flatMap(LoggerService, (l) => Effect.succeed(l)), layer));
+    const sync = createSyncLogger(logger);
+
+    // set global trace for SyncLogger path
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (globalThis as any).__onebunCurrentTraceContext = { traceId: 't123456789', spanId: 's123456789' };
+
+    const child = sync.child({ className: 'Child' });
+    child.info('hi');
+
+    expect(outputs[0].context?.className).toBe('Child');
+    expect(outputs[0].trace?.traceId).toBe('t123456789');
+  });
+});
+
+
+// Additional tests to improve coverage near 100%
+
+describe('PrettyFormatter - additional value shapes', () => {
+  it('formats various value types in additionalData', () => {
+    const f = new PrettyFormatter();
+    const err = new Error('X');
+    const fn = function namedFn() {
+      return 1;
+    };
+    const entry: LogEntry = {
+      level: LogLevel.Debug,
+      message: 'v',
+      timestamp: new Date('2025-01-01T00:00:00.000Z'),
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      context: { __additionalData: [null, undefined, 123, 's', false, new Date('2025-01-01T00:00:00.000Z'), err, fn] },
+    };
+    const out = f.format(entry);
+    expect(out).toContain('null');
+    expect(out).toContain('undefined');
+    expect(out).toContain('123');
+    expect(out).toContain('"s"');
+    expect(out).toContain('false');
+    expect(out).toContain('2025-01-01T00:00:00.000Z');
+    expect(out).toContain('Error: X');
+    expect(out).toContain('[Function: namedFn]');
+  });
+
+  it('pretty prints empty and deep structures with truncation', () => {
+    const f = new PrettyFormatter();
+    const deep = { a: { b: { c: { d: 1 } } } };
+    const entry: LogEntry = {
+      level: LogLevel.Info,
+      message: 'ctx',
+      timestamp: new Date('2025-01-01T00:00:00.000Z'),
+      context: { emptyObj: {}, emptyArr: [], deep },
+    };
+    const out = f.format(entry);
+    expect(out).toContain('emptyObj');
+    expect(out).toContain('{}');
+    expect(out).toContain('emptyArr');
+    expect(out).toContain('[]');
+    // при глубокой структуре встречается маркер [Object]
+    expect(out).toContain('[Object]');
+  });
+});
+
+describe('JsonFormatter - variants', () => {
+  it('omits context and additionalData when absent; trace without parent', () => {
+    const f = new JsonFormatter();
+    const entry: LogEntry = {
+      level: LogLevel.Trace,
+      message: 'j',
+      timestamp: new Date('2025-01-01T00:00:00.000Z'),
+      trace: { traceId: 'tt', spanId: 'ss' },
+    };
+    const o = JSON.parse(f.format(entry));
+    expect(o.level).toBe('trace');
+    expect(o.context).toBeUndefined();
+    expect(o.additionalData).toBeUndefined();
+    expect(o.trace.traceId).toBe('tt');
+    expect(o.trace.parentSpanId).toBeUndefined();
+  });
+});
+
+describe('LoggerImpl methods and makeLogger env selection', () => {
+  it('calls all level methods at or above minLevel', () => {
+    const seen: LogEntry[] = [];
+    const transport = new (class extends ConsoleTransport {
+      override log(_formatted: string, e: LogEntry) {
+        return Effect.sync(() => {
+          seen.push(e);
+        });
+      }
+    })();
+    const layer = makeDevLogger({ minLevel: LogLevel.Trace, transport });
+    const logger = Effect.runSync(Effect.provide(Effect.flatMap(LoggerService, (l) => Effect.succeed(l)), layer));
+    const sync = createSyncLogger(logger);
+    sync.trace('t');
+    sync.debug('d');
+    sync.info('i');
+    sync.warn('w');
+    sync.error('e', new Error('E1'));
+    sync.fatal('f', new Error('E2'));
+    expect(seen.map((e) => e.level)).toEqual([
+      LogLevel.Trace, LogLevel.Debug, LogLevel.Info, LogLevel.Warning, LogLevel.Error, LogLevel.Fatal,
+    ]);
+  });
+
+  it('makeLogger picks prod logger when NODE_ENV=production', () => {
+    const prev = process.env.NODE_ENV;
+    process.env.NODE_ENV = 'production';
+    const seen: LogEntry[] = [];
+    const transport = new (class extends ConsoleTransport {
+      override log(_formatted: string, e: LogEntry) {
+        return Effect.sync(() => {
+          seen.push(e);
+        });
+      }
+    })();
+    const layer = makeLogger({ transport });
+    const logger = Effect.runSync(Effect.provide(Effect.flatMap(LoggerService, (l) => Effect.succeed(l)), layer));
+    const sync = createSyncLogger(logger);
+    // Debug должен быть отфильтрован в prod (minLevel Info)
+    sync.debug('dbg');
+    sync.info('ok');
+    expect(seen.length).toBe(1);
+    expect(seen[0].level).toBe(LogLevel.Info);
+    process.env.NODE_ENV = prev;
+  });
+});
+
+describe('LoggerImpl trace context fallback to __onebunTraceService', () => {
+  it('uses global trace service when current trace context is absent', () => {
+    // очистить direct context
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (globalThis as any).__onebunCurrentTraceContext = undefined;
+    const outputs: LogEntry[] = [];
+    const transport = new (class extends ConsoleTransport {
+      override log(_f: string, e: LogEntry) {
+        return Effect.sync(() => {
+          outputs.push(e);
+        });
+      }
+    })();
+    // подготовить псевдо trace service
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (globalThis as any).__onebunTraceService = {
+      getCurrentTraceContext: () => Effect.succeed({ traceId: 'svc-trace', spanId: 'svc-span' }),
+    };
+
+    const layer = makeDevLogger({ transport });
+    const logger = Effect.runSync(Effect.provide(Effect.flatMap(LoggerService, (l) => Effect.succeed(l)), layer));
+    const sync = createSyncLogger(logger);
+    sync.info('ping');
+
+    expect(outputs[0].trace?.traceId).toBe('svc-trace');
+  });
+});
+
+
+// Added tests to raise function coverage for formatter.ts
+
+describe('Formatter getLevelName coverage', () => {
+  it('JsonFormatter maps all levels to lowercase names', () => {
+    const f = new JsonFormatter();
+    const ts = new Date('2025-01-01T00:00:00.000Z');
+    const mk = (level: LogLevel) => JSON.parse(f.format({ level, message: 'm', timestamp: ts })).level as string;
+    expect(mk(LogLevel.Trace)).toBe('trace');
+    expect(mk(LogLevel.Debug)).toBe('debug');
+    expect(mk(LogLevel.Info)).toBe('info');
+    expect(mk(LogLevel.Warning)).toBe('warn');
+    expect(mk(LogLevel.Error)).toBe('error');
+    expect(mk(LogLevel.Fatal)).toBe('fatal');
+  });
+
+  it('PrettyFormatter maps TRACE and FATAL to bracketed level names', () => {
+    const f = new PrettyFormatter();
+    const ts = new Date('2025-01-01T00:00:00.000Z');
+    const outTrace = f.format({ level: LogLevel.Trace, message: 't', timestamp: ts });
+    const outFatal = f.format({ level: LogLevel.Fatal, message: 'f', timestamp: ts });
+    expect(outTrace).toContain('[TRACE  ]');
+    expect(outFatal).toContain('[FATAL  ]');
+  });
+});
+
+describe('formatValue rare branches via PrettyFormatter additionalData', () => {
+  it('handles empty array and multi-element array with pretty multi-line', () => {
+    const f = new PrettyFormatter();
+    const ts = new Date('2025-01-01T00:00:00.000Z');
+    const outEmpty = f.format({
+      level: LogLevel.Debug,
+      message: 'empty',
+      timestamp: ts,
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      context: { __additionalData: [[]] },
+    });
+    expect(outEmpty).toContain('[]');
+
+    const outNonEmpty = f.format({
+      level: LogLevel.Debug,
+      message: 'nonempty',
+      timestamp: ts,
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      context: { __additionalData: [[1, 2, 3]] },
+    });
+    // Ожидаем многострочное форматирование массива (наличие символов [ и ] с переносами строк)
+    expect(outNonEmpty).toMatch(/\[\x1b\[0m\n/); // присутствует перевод строки после [
+  });
+
+  it('handles deep nested array producing [Array] marker when depth exceeded', () => {
+    const f = new PrettyFormatter();
+    const deepArr = [[[[[1]]]]]; // глубина 5 (> MAX_OBJECT_DEPTH)
+    const out = f.format({
+      level: LogLevel.Debug,
+      message: 'deep',
+      timestamp: new Date('2025-01-01T00:00:00.000Z'),
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      context: { __additionalData: [deepArr] },
+    });
+    expect(out).toContain('[Array]');
+  });
+
+  it('formats object keys that require quotes', () => {
+    const f = new PrettyFormatter();
+    const out = f.format({
+      level: LogLevel.Info,
+      message: 'obj',
+      timestamp: new Date('2025-01-01T00:00:00.000Z'),
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      context: { 'a-b': 1 },
+    });
+    // Ключ с дефисом должен печататься в кавычках
+    expect(out).toContain('"a-b"');
+  });
+
+  it('prints anonymous function with fallback name and covers String(value) for symbol and bigint', () => {
+    const f = new PrettyFormatter();
+    // анонимная функция
+
+    const anon = function () {
+      return 0;
+    };
+    const sym = Symbol('s');
+    const big = BigInt(42);
+    const out = f.format({
+      level: LogLevel.Debug,
+      message: 'misc',
+      timestamp: new Date('2025-01-01T00:00:00.000Z'),
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      context: { __additionalData: [anon, sym, big] },
+    });
+    expect(out).toContain('[Function:');
+    // символы и бигинты проходят в String(value)
+    expect(out).toContain('Symbol(s)');
+    expect(out).toContain('42');
+  });
+});
+
+describe('Formatter edge cases and additional coverage', () => {
+  it('PrettyFormatter should handle Set and Map objects', () => {
+    const formatter = new PrettyFormatter();
+    const set = new Set([1, 2, 3]);
+    const map = new Map([['key', 'value']]);
+
+    const out = formatter.format({
+      level: LogLevel.Info,
+      message: 'collections',
+      timestamp: new Date('2025-01-01T00:00:00.000Z'),
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      context: { __additionalData: [set, map] },
+    });
+
+    // Sets and Maps are formatted as empty objects {} in the formatter
+    expect(out).toContain('{}');
+    expect(out).toContain('collections');
+  });
+
+  it('PrettyFormatter should handle Date objects', () => {
+    const formatter = new PrettyFormatter();
+    const date = new Date('2025-01-01T12:00:00.000Z');
+
+    const out = formatter.format({
+      level: LogLevel.Info,
+      message: 'dates',
+      timestamp: new Date('2025-01-01T00:00:00.000Z'),
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      context: { __additionalData: [date] },
+    });
+
+    expect(out).toContain('2025');
+  });
+
+  it('PrettyFormatter should handle class instances', () => {
+    const formatter = new PrettyFormatter();
+    
+    class TestClass {
+      prop = 'value';
+    }
+    
+    const instance = new TestClass();
+
+    const out = formatter.format({
+      level: LogLevel.Info,
+      message: 'instance',
+      timestamp: new Date('2025-01-01T00:00:00.000Z'),
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      context: { __additionalData: [instance] },
+    });
+
+    // Class instances show their properties, not class name
+    expect(out).toContain('prop');
+    expect(out).toContain('value');
+  });
+
+  it('JsonFormatter should handle all log levels correctly', () => {
+    const formatter = new JsonFormatter();
+    const timestamp = new Date('2025-01-01T00:00:00.000Z');
+
+    // Test all log levels
+    const levels = [LogLevel.Trace, LogLevel.Debug, LogLevel.Info, LogLevel.Warning, LogLevel.Error, LogLevel.Fatal];
+    
+    levels.forEach(level => {
+      const out = formatter.format({
+        level,
+        message: 'test',
+        timestamp,
+      });
+      
+      const parsed = JSON.parse(out);
+      expect(parsed.level).toBeDefined();
+      expect(parsed.message).toBe('test');
+    });
+  });
+
+  it('PrettyFormatter should handle complex nested structures with formatting', () => {
+    const formatter = new PrettyFormatter();
+    
+    const complexData = {
+      level1: {
+        level2: {
+          level3: {
+            deep: 'value',
+            array: [1, 2, { nested: true }],
+          },
+        },
+      },
+    };
+
+    const out = formatter.format({
+      level: LogLevel.Info,
+      message: 'complex',
+      timestamp: new Date('2025-01-01T00:00:00.000Z'),
+      context: complexData,
+    });
+
+    expect(out).toContain('level1');
+    expect(out).toContain('level2');
+    expect(out).toContain('level3');
+  });
+});

package/src/logger.ts

@@ -0,0 +1,308 @@
+import {
+  Context,
+  Effect,
+  FiberRef,
+  Layer,
+} from 'effect';
+
+import { JsonFormatter, PrettyFormatter } from './formatter';
+import { ConsoleTransport } from './transport';
+import {
+  type LoggerConfig,
+  LogLevel,
+  type TraceInfo,
+} from './types';
+
+/**
+ * Custom logger service interface
+ */
+export type Logger = {
+  trace(message: string, ...args: unknown[]): Effect.Effect<void>;
+  debug(message: string, ...args: unknown[]): Effect.Effect<void>;
+  info(message: string, ...args: unknown[]): Effect.Effect<void>;
+  warn(message: string, ...args: unknown[]): Effect.Effect<void>;
+  error(message: string, ...args: unknown[]): Effect.Effect<void>;
+  fatal(message: string, ...args: unknown[]): Effect.Effect<void>;
+  child(context: Record<string, unknown>): Logger;
+};
+
+/**
+ * Synchronous logger interface for convenience
+ */
+export type SyncLogger = {
+  trace(message: string, ...args: unknown[]): void;
+  debug(message: string, ...args: unknown[]): void;
+  info(message: string, ...args: unknown[]): void;
+  warn(message: string, ...args: unknown[]): void;
+  error(message: string, ...args: unknown[]): void;
+  fatal(message: string, ...args: unknown[]): void;
+  child(context: Record<string, unknown>): SyncLogger;
+};
+
+/**
+ * Context tag for the Logger service
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const LoggerService = Context.GenericTag<Logger>('LoggerService');
+
+/**
+ * Current trace context stored in fiber for automatic trace inclusion in logs
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const CurrentLoggerTraceContext = FiberRef.unsafeMake<TraceInfo | null>(null);
+
+/**
+ * Parse arguments to extract error, context and additional data
+ */
+function parseLogArgs(args: unknown[]): {
+  error?: Error;
+  context?: Record<string, unknown>;
+  additionalData?: unknown[];
+} {
+  if (args.length === 0) {
+    return {};
+  }
+
+  let error: Error | undefined;
+  let context: Record<string, unknown> | undefined;
+  const additionalData: unknown[] = [];
+
+  for (const arg of args) {
+    if (arg instanceof Error) {
+      // First error found becomes the main error
+      if (!error) {
+        error = arg;
+      } else {
+        additionalData.push(arg);
+      }
+    } else if (
+      arg &&
+      typeof arg === 'object' &&
+      !Array.isArray(arg) &&
+      arg.constructor === Object
+    ) {
+      // Plain objects are merged into context
+      context = { ...context, ...(arg as Record<string, unknown>) };
+    } else {
+      // Everything else goes to additional data
+      additionalData.push(arg);
+    }
+  }
+
+  return {
+    error,
+    context: Object.keys(context || {}).length > 0 ? context : undefined,
+    additionalData: additionalData.length > 0 ? additionalData : undefined,
+  };
+}
+
+/**
+ * Simple logger implementation that uses our formatters and transports
+ */
+class LoggerImpl implements Logger {
+  constructor(
+    private config: LoggerConfig,
+    private context: Record<string, unknown> = {},
+  ) {}
+
+  private log(level: LogLevel, message: string, ...args: unknown[]): Effect.Effect<void> {
+    // Check minimum logging level
+    if (level < this.config.minLevel) {
+      return Effect.succeed(undefined);
+    }
+
+    return Effect.flatMap(FiberRef.get(CurrentLoggerTraceContext), (traceInfo) => {
+      // Try to get trace context from global context or trace service
+      let currentTraceInfo = traceInfo;
+      if (!currentTraceInfo && typeof globalThis !== 'undefined') {
+        // Try global trace context first
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const globalTraceContext = (globalThis as any).__onebunCurrentTraceContext;
+        if (globalTraceContext && globalTraceContext.traceId) {
+          currentTraceInfo = globalTraceContext;
+        } else {
+          // Fallback to trace service
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const globalTraceService = (globalThis as any).__onebunTraceService;
+          if (globalTraceService && globalTraceService.getCurrentTraceContext) {
+            try {
+              // Extract current trace context from global trace service
+               
+              const currentContext = Effect.runSync(
+                globalTraceService.getCurrentTraceContext(),
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              ) as any;
+              if (currentContext && currentContext.traceId) {
+                currentTraceInfo = {
+                  traceId: currentContext.traceId,
+                  spanId: currentContext.spanId,
+                  parentSpanId: currentContext.parentSpanId,
+                };
+              }
+            } catch {
+              // Ignore errors getting trace context
+            }
+          }
+        }
+      }
+
+      // Parse additional arguments
+      const { error, context: argsContext, additionalData } = parseLogArgs(args);
+
+      // Merge contexts
+      const mergedContext = {
+        ...this.config.defaultContext,
+        ...this.context,
+        ...argsContext,
+      };
+
+      // Add additional data to context if present
+      if (additionalData && additionalData.length > 0) {
+        mergedContext.__additionalData = additionalData;
+      }
+
+      // Create log entry
+      const entry = {
+        level,
+        message,
+        timestamp: new Date(),
+        context: Object.keys(mergedContext).length > 0 ? mergedContext : undefined,
+        error,
+        trace: currentTraceInfo || undefined,
+      };
+
+      // Format and send through transport
+      const formattedEntry = this.config.formatter.format(entry);
+
+      return this.config.transport.log(formattedEntry, entry);
+    });
+  }
+
+  trace(message: string, ...args: unknown[]): Effect.Effect<void> {
+    return this.log(LogLevel.Trace, message, ...args);
+  }
+
+  debug(message: string, ...args: unknown[]): Effect.Effect<void> {
+    return this.log(LogLevel.Debug, message, ...args);
+  }
+
+  info(message: string, ...args: unknown[]): Effect.Effect<void> {
+    return this.log(LogLevel.Info, message, ...args);
+  }
+
+  warn(message: string, ...args: unknown[]): Effect.Effect<void> {
+    return this.log(LogLevel.Warning, message, ...args);
+  }
+
+  error(message: string, ...args: unknown[]): Effect.Effect<void> {
+    return this.log(LogLevel.Error, message, ...args);
+  }
+
+  fatal(message: string, ...args: unknown[]): Effect.Effect<void> {
+    return this.log(LogLevel.Fatal, message, ...args);
+  }
+
+  child(context: Record<string, unknown>): Logger {
+    return new LoggerImpl(this.config, { ...this.context, ...context });
+  }
+}
+
+/**
+ * Creates a development logger with pretty console output
+ */
+export const makeDevLogger = (config?: Partial<LoggerConfig>): Layer.Layer<Logger> => {
+  return Layer.succeed(
+    LoggerService,
+    new LoggerImpl({
+      minLevel: LogLevel.Debug,
+      formatter: new PrettyFormatter(),
+      transport: new ConsoleTransport(),
+      defaultContext: {},
+      ...config,
+    }),
+  );
+};
+
+/**
+ * Creates a production logger with JSON output
+ */
+export const makeProdLogger = (config?: Partial<LoggerConfig>): Layer.Layer<Logger> => {
+  return Layer.succeed(
+    LoggerService,
+    new LoggerImpl({
+      minLevel: LogLevel.Info,
+      formatter: new JsonFormatter(),
+      transport: new ConsoleTransport(),
+      defaultContext: {},
+      ...config,
+    }),
+  );
+};
+
+/**
+ * Synchronous logger wrapper
+ */
+class SyncLoggerImpl implements SyncLogger {
+  constructor(private logger: Logger) {}
+
+  private runWithTraceContext<T>(effect: Effect.Effect<T>): T {
+    // Try to get trace context from global context
+    let traceEffect = effect;
+    if (typeof globalThis !== 'undefined') {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const globalTraceContext = (globalThis as any).__onebunCurrentTraceContext;
+      if (globalTraceContext && globalTraceContext.traceId) {
+        traceEffect = Effect.provide(
+          Effect.flatMap(FiberRef.set(CurrentLoggerTraceContext, globalTraceContext), () => effect),
+          Layer.empty,
+        );
+      }
+    }
+
+    return Effect.runSync(traceEffect);
+  }
+
+  trace(message: string, ...args: unknown[]): void {
+    this.runWithTraceContext(this.logger.trace(message, ...args));
+  }
+
+  debug(message: string, ...args: unknown[]): void {
+    this.runWithTraceContext(this.logger.debug(message, ...args));
+  }
+
+  info(message: string, ...args: unknown[]): void {
+    this.runWithTraceContext(this.logger.info(message, ...args));
+  }
+
+  warn(message: string, ...args: unknown[]): void {
+    this.runWithTraceContext(this.logger.warn(message, ...args));
+  }
+
+  error(message: string, ...args: unknown[]): void {
+    this.runWithTraceContext(this.logger.error(message, ...args));
+  }
+
+  fatal(message: string, ...args: unknown[]): void {
+    this.runWithTraceContext(this.logger.fatal(message, ...args));
+  }
+
+  child(context: Record<string, unknown>): SyncLogger {
+    return new SyncLoggerImpl(this.logger.child(context));
+  }
+}
+
+/**
+ * Create a synchronous logger from async logger
+ */
+export const createSyncLogger = (logger: Logger): SyncLogger => {
+  return new SyncLoggerImpl(logger);
+};
+
+/**
+ * Create a logger based on NODE_ENV
+ */
+export const makeLogger = (config?: Partial<LoggerConfig>): Layer.Layer<Logger> => {
+  const isDev = process.env.NODE_ENV !== 'production';
+
+  return isDev ? makeDevLogger(config) : makeProdLogger(config);
+};

package/src/transport.ts

@@ -0,0 +1,37 @@
+import { Effect } from 'effect';
+
+import {
+  type LogEntry,
+  LogLevel,
+  type LogTransport,
+} from './types';
+
+/**
+ * Console transport for logging
+ */
+export class ConsoleTransport implements LogTransport {
+  log(formattedEntry: string, entry: LogEntry): Effect.Effect<void> {
+    return Effect.sync(() => {
+      switch (entry.level) {
+        case LogLevel.Error:
+        case LogLevel.Fatal:
+          // eslint-disable-next-line no-console
+          console.error(formattedEntry);
+          break;
+        case LogLevel.Warning:
+          // eslint-disable-next-line no-console
+          console.warn(formattedEntry);
+          break;
+        case LogLevel.Info:
+          // eslint-disable-next-line no-console
+          console.info(formattedEntry);
+          break;
+        case LogLevel.Debug:
+        case LogLevel.Trace:
+        default:
+          // eslint-disable-next-line no-console
+          console.log(formattedEntry);
+      }
+    });
+  }
+}

package/src/types.ts

@@ -0,0 +1,61 @@
+import type { Effect } from 'effect';
+
+/**
+ * Определяем уровни логирования
+ */
+/* eslint-disable no-magic-numbers -- Standard log levels based on syslog defined in one place */
+export enum LogLevel {
+  Fatal = 60,
+  Error = 50,
+  Warning = 40,
+  Info = 30,
+  Debug = 20,
+  Trace = 10,
+  None = 0,
+}
+/* eslint-enable no-magic-numbers */
+
+/**
+ * Trace information for log entries
+ */
+export interface TraceInfo {
+  traceId: string;
+  spanId: string;
+  parentSpanId?: string;
+}
+
+/**
+ * Log entry structure
+ */
+export interface LogEntry {
+  level: LogLevel;
+  message: string;
+  timestamp: Date;
+  context?: Record<string, unknown>;
+  error?: Error;
+  trace?: TraceInfo;
+}
+
+/**
+ * Log formatter interface
+ */
+export interface LogFormatter {
+  format(entry: LogEntry): string;
+}
+
+/**
+ * Log transport interface
+ */
+export interface LogTransport {
+  log(formattedEntry: string, entry: LogEntry): Effect.Effect<void>;
+}
+
+/**
+ * Logger configuration
+ */
+export interface LoggerConfig {
+  minLevel: LogLevel;
+  formatter: LogFormatter;
+  transport: LogTransport;
+  defaultContext?: Record<string, unknown>;
+}