chore: cleaning up codebase

Author: aryanjassal

README.md

@@ -4,7 +4,7 @@ This library provides a JavaScript/TypeScript logger inspired by Python's logger
 
 * Simple logging with default handlers supporting `console.log`, `console.error`, and `process.stderr`.
 * Fast, logging level checks or log filters are applied **before** log records are created
-* Complex log records properties ssupport lazy evaluation, so they evaluated only when they need to be rendered
+* Complex log records properties support lazy evaluation, so they evaluated only when they need to be rendered
 * Flexible composition of loggers, handlers and formatters
 * Custom formatting using template literals
 * Supports structured logging through a JSON formatter

span.jsonl

@@ -0,0 +1,5 @@
+{"span":{"spanId":"span-1744864565062-s7b","name":"Parent-0","startTime":1744864565062,"isCompleted":false,"children":[]},"type":"start"}
+{"span":{"spanId":"span-1744864566561-sz0","name":"Async-Chain-0","startTime":1744864566561,"isCompleted":false,"children":[]},"type":"start"}
+{"span":{"spanId":"span-1744864566561-aic","name":"Async-Job-1","startTime":1744864566561,"parentSpanId":"span-1744864565062-s7b","isCompleted":false,"children":[]},"type":"start"}
+{"span":{"spanId":"span-1744864566561-qdt","name":"Async-Job-2","startTime":1744864566561,"parentSpanId":"span-1744864566561-aic","isCompleted":false,"children":[]},"type":"start"}
+{"span":{"spanId":"span-1744864566561-sz0","name":"Async-Chain-0","startTime":1744864566561,"endTime":1744864566561,"isCompleted":true,"children":[]},"type":"end"}

src/Logger.ts

@@ -3,7 +3,7 @@ import type Handler from './Handler.js';
 import { LogLevel } from './types.js';
 import ConsoleErrHandler from './handlers/ConsoleErrHandler.js';
 import * as utils from './utils.js';
-import { openSpan, closeSpan } from './lib/tracingManager.js';
+import { openSpan, closeSpan } from './lib/TracingManager.js';
 
 class Logger {
   public readonly key: string;

src/bin/SpanTree.tsx

@@ -1,5 +1,4 @@
 import type { FC } from 'react';
-import React from 'react';
 import { Box, Text } from 'ink';
 import Span from '../lib/Span.js';
 

src/bin/TimeLineView.tsx

@@ -1,5 +1,4 @@
 import type { FC } from 'react';
-import React from 'react';
 import { Box, Text } from 'ink';
 
 interface Span {

src/bin/cli.tsx

@@ -1,7 +1,7 @@
 import type Span from '../lib/Span.js';
 import fs from 'fs';
 import { Command } from 'commander';
-import React, { useEffect, useState } from 'react';
+import { useEffect, useState } from 'react';
 import { render, Box, Text } from 'ink';
 import SpanTree from './SpanTree.js';
 
@@ -14,17 +14,24 @@ program
 const options = program.opts();
 const sampleMode = options.sample;
 
-function loadSpans(): Span[] {
-  if (!fs.existsSync('spans.json')) return [];
-  return JSON.parse(fs.readFileSync('spans.json', 'utf8')) as Span[];
+async function loadSpans(): Promise<Array<Span>> {
+  if (!fs.existsSync('spans.jsonl')) return [];
+  const spans: Array<Span> = [];
+  const file = await fs.promises.open('testSpans.jsonl', 'r');
+  for await (const line of file.readLines()) {
+    spans.push(JSON.parse(line));
+  }
+  await file.close();
+  return spans;
+  // return JSON.parse(fs.readFileSync('spans.json', 'utf8')) as Span[];
 }
 
 const App = () => {
-  const [spans, setSpans] = useState<Span[]>([]);
+  const [spans, setSpans] = useState<Array<Span>>([]);
 
   useEffect(() => {
     const id = setInterval(() => {
-      setSpans(loadSpans());
+      loadSpans().then(setSpans);
     }, 1000);
 
     const handleExit = () => {

src/index.ts

@@ -1,6 +1,6 @@
 export { default } from './Logger.js';
 export { default as Handler } from './Handler.js';
-export { openSpan, closeSpan, getTraceJSON } from './lib/tracingManager.js';
+export { openSpan, closeSpan, getTraceJSON } from './lib/TracingManager.js';
 export { default as Span } from './lib/Span.js';
 export * as formatting from './formatting.js';
 export * from './handlers/index.js';

src/lib/Span.ts

@@ -1,41 +1,29 @@
-export interface SpanJSON {
-  spanId: string;
-  name: string;
-  startTime: number;
-  endTime: number | undefined;
-  parentSpanId: string | undefined;
-  isCompleted: boolean;
-  children: SpanJSON[];
-}
+import type { SpanJSON } from './types.js';
 
 class Span {
-  public spanId: string;
+  public spanId: string = `span-${Date.now()}-${Math.random()
+    .toString(36)
+    .substring(2, 5)}`;
   public name: string;
-  public startTime: number;
+  public startTime: number = Date.now();
   public endTime?: number;
   public parentSpanId?: string;
-  public children: Array<Span>;
+  public children: Array<Span> = [];
 
-  constructor(name: string, parentSpanId: string | undefined = undefined) {
-    this.spanId = `span-${Date.now()}-${Math.random()
-      .toString(36)
-      .substr(2, 5)}`;
+  constructor(name: string, parentSpanId?: string) {
     this.name = name;
-    this.startTime = Date.now();
-    this.endTime = undefined;
     this.parentSpanId = parentSpanId;
-    this.children = [];
   }
 
   public close(): void {
     this.endTime = Date.now();
   }
 
   public isCompleted(): boolean {
-    return this.endTime !== undefined;
+    return this.endTime != null;
   }
 
-  toJSON(): SpanJSON {
+  public toJSON(): SpanJSON {
     return {
       spanId: this.spanId,
       name: this.name,

src/lib/Tracer.ts

@@ -1,10 +1,15 @@
-import fs from 'fs';
 import Span from './Span.js';
 
-export default class Tracer {
-  private activeSpans: Map<string, Span> = new Map();
-  private spanFile = 'spans.json';
-  private jsonlStream = fs.createWriteStream('spans.jsonl', { flags: 'a' });
+class Tracer {
+  protected activeSpans: Map<string, Span> = new Map();
+  protected queue: Array<Span> = [];
+  protected resolveWaitChunksP: (() => void) | undefined;
+  protected ended: boolean = false;
+
+  protected queueSpan(span: Span) {
+    this.queue.push(span);
+    if (this.resolveWaitChunksP != null) this.resolveWaitChunksP();
+  }
 
   public startSpan(name: string, parentSpanId?: string): string {
     const span = new Span(name, parentSpanId);
@@ -14,45 +19,31 @@ export default class Tracer {
       this.activeSpans.get(parentSpanId)!.children.push(span);
     }
 
-    this.saveSpansToFile();
     return span.spanId;
   }
 
-  public endSpan(spanId: string): Span | null {
+  public endSpan(spanId: string): Span | undefined {
     const span = this.activeSpans.get(spanId);
-    if (!span) return null;
+    if (!span) return;
 
     span.close();
-    this.jsonlStream.write(JSON.stringify(span.toJSON()) + '\n');
-    this.saveSpansToFile();
+    this.queueSpan(span);
     return span;
   }
 
-  public traced<T>(
+  public async traced<T>(
     name: string,
     fn: () => Promise<T>,
     parentSpanId?: string,
   ): Promise<T> {
     const spanId = this.startSpan(name, parentSpanId);
-    return fn()
-      .then((result) => {
-        this.endSpan(spanId);
-        return result;
-      })
-      .catch((err) => {
-        this.endSpan(spanId);
-        throw err;
-      });
+    return await fn().finally(() => this.endSpan(spanId));
   }
 
-  public getActiveSpans(): Span[] {
+  public getActiveSpans(): Array<Span> {
     return Array.from(this.activeSpans.values());
   }
 
-  public flush(): void {
-    this.saveSpansToFile();
-  }
-
   public getTraceJSON(): string {
     return JSON.stringify(
       this.getActiveSpans().map((s) => s.toJSON()),
@@ -61,10 +52,23 @@ export default class Tracer {
     );
   }
 
-  private saveSpansToFile(): void {
-    fs.writeFileSync(
-      this.spanFile,
-      JSON.stringify(this.getActiveSpans(), null, 2),
-    );
+  public endTracing(): void {
+    this.ended = true;
+  }
+
+  public async *streamEvents(): AsyncGenerator<Span, void, void> {
+    while (true) {
+      const value = this.queue.shift();
+      if (value == null) {
+        if (this.ended) break;
+        await new Promise<void>((resolve) => {
+          this.resolveWaitChunksP = resolve;
+        });
+        continue;
+      }
+      yield value;
+    }
   }
 }
+
+export default Tracer;

src/lib/TracingManager.ts

@@ -0,0 +1,27 @@
+import Tracer from '#lib/Tracer.js';
+
+const tracer = new Tracer();
+
+const openSpan = (spanId: string, parentSpanId?: string) =>
+  tracer.startSpan(spanId, parentSpanId);
+const closeSpan = (spanId: string) => tracer.endSpan(spanId);
+const traced = (
+  name: string,
+  fn: () => Promise<unknown>,
+  parentSpanId?: string,
+) => tracer.traced(name, fn, parentSpanId);
+const getActiveSpans = () => tracer.getActiveSpans();
+const getTraceJSON = () => tracer.getTraceJSON();
+const streamEvents = () => tracer.streamEvents();
+const endTracing = () => tracer.endTracing();
+
+export default tracer;
+export {
+  openSpan,
+  closeSpan,
+  traced,
+  getActiveSpans,
+  getTraceJSON,
+  streamEvents,
+  endTracing,
+};