drtrace 0.2.0 → 0.4.0

package/dist/transport.js

@@ -15,7 +15,11 @@ class Transport {
         if (events.length === 0)
             return;
         const url = `${this.daemonUrl}/logs/ingest`;
-        const payload = { logs: events };
+        // Wrap batch with application_id at top level as required by daemon API
+        const payload = {
+            application_id: events[0].application_id,
+            logs: events,
+        };
         const fetchImpl = globalThis.fetch;
         if (!fetchImpl)
             return; // Non-blocking skip

package/dist/types.d.ts

@@ -1,14 +1,20 @@
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 export interface LogEvent {
-    timestamp: string;
-    applicationId: string;
+    ts: number;
     level: LogLevel;
     message: string;
+    application_id: string;
+    module_name: string;
     context?: Record<string, unknown>;
 }
+export interface LogBatch {
+    application_id: string;
+    logs: LogEvent[];
+}
 export interface ClientOptions {
     applicationId: string;
     daemonUrl: string;
+    moduleName?: string;
     enabled?: boolean;
     logLevel?: LogLevel;
     batchSize?: number;

package/package.json

@@ -1,20 +1,28 @@
 {
   "name": "drtrace",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "DrTrace JavaScript/TypeScript client",
   "main": "dist/index.js",
+  "browser": "dist/browser.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
+      "browser": "./dist/browser.js",
+      "node": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "default": "./dist/browser.js"
     }
   },
   "bin": {
     "drtrace": "dist/bin/init.js"
   },
   "scripts": {
-    "build": "tsc",
+    "prebuild": "node scripts/copy-agents.js",
+    "build": "tsc && mkdir -p dist/bin && cp bin/init.js dist/bin/init.js && chmod +x dist/bin/init.js && mkdir -p dist/resources/agents && (cp -r agents/* dist/resources/agents/ 2>/dev/null || true) && (cp -r ../../../agents/integration-guides/* dist/resources/agents/integration-guides/ 2>/dev/null || true) && mkdir -p dist/resources/cpp && cp ../../../packages/cpp/drtrace-client/src/drtrace_sink.hpp dist/resources/cpp/ 2>/dev/null || true",
     "test": "jest",
     "test:watch": "jest --watch",
     "lint": "eslint src --ext .ts",
@@ -44,11 +52,27 @@
     "error-tracking",
     "debugging"
   ],
-  "author": "DrTrace Team",
+  "author": {
+    "name": "Thanh Cao",
+    "email": "caoduythanhcantho@gmail.com"
+  },
   "license": "MIT",
+  "files": [
+    "dist/",
+    "agents/",
+    "bin/",
+    "resources/"
+  ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/example/drtrace.git",
+    "url": "git+https://github.com/CaoDuyThanh/drtrace.git",
     "directory": "packages/javascript/drtrace-client"
+  },
+  "homepage": "https://github.com/CaoDuyThanh/drtrace#readme",
+  "bugs": {
+    "url": "https://github.com/CaoDuyThanh/drtrace/issues"
+  },
+  "engines": {
+    "node": ">=16.0.0"
   }
 }

package/.eslintrc.js

@@ -1,20 +0,0 @@
-module.exports = {
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    ecmaVersion: 2020,
-    sourceType: 'module',
-  },
-  extends: [
-    'eslint:recommended',
-    'plugin:@typescript-eslint/recommended',
-  ],
-  plugins: ['@typescript-eslint'],
-  env: {
-    node: true,
-    es6: true,
-  },
-  rules: {
-    '@typescript-eslint/explicit-module-boundary-types': 'off',
-    '@typescript-eslint/no-explicit-any': 'warn',
-  },
-};

package/jest.config.js

@@ -1,11 +0,0 @@
-module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-  roots: ['<rootDir>/tests'],
-  testMatch: ['**/*.test.ts'],
-  collectCoverageFrom: [
-    'src/**/*.ts',
-    '!src/**/*.d.ts',
-  ],
-  moduleFileExtensions: ['ts', 'js', 'json'],
-};

package/src/client.ts

@@ -1,68 +0,0 @@
-import { loadConfig } from './config';
-import { Transport } from './transport';
-import { LogQueue } from './queue';
-import { DrTraceLogger } from './logger';
-import type { ClientOptions, LogLevel } from './types';
-
-export class DrTrace {
-  private queue: LogQueue;
-  private logger: DrTraceLogger;
-  private enabled: boolean;
-
-  private constructor(opts: ClientOptions) {
-    const transport = new Transport({
-      daemonUrl: opts.daemonUrl,
-      maxRetries: opts.maxRetries ?? 3,
-      timeoutMs: 5000,
-    });
-    this.queue = new LogQueue({
-      transport,
-      batchSize: opts.batchSize ?? 50,
-      flushIntervalMs: opts.flushIntervalMs ?? 1000,
-      maxQueueSize: opts.maxQueueSize ?? 10000,
-    });
-    this.queue.start();
-
-    this.enabled = opts.enabled ?? true;
-    this.logger = new DrTraceLogger({ queue: this.queue, applicationId: opts.applicationId, logLevel: (opts.logLevel ?? 'info') as LogLevel });
-  }
-
-  static init(opts?: Partial<ClientOptions>): DrTrace {
-    const cfg = loadConfig({ projectRoot: '.', environment: process.env.NODE_ENV });
-    const merged: ClientOptions = {
-      applicationId: cfg.drtrace.applicationId,
-      daemonUrl: cfg.drtrace.daemonUrl || 'http://localhost:8001',
-      enabled: cfg.drtrace.enabled ?? true,
-      logLevel: (cfg.drtrace.logLevel ?? 'info') as LogLevel,
-      batchSize: cfg.drtrace.batchSize ?? 50,
-      flushIntervalMs: cfg.drtrace.flushIntervalMs ?? 1000,
-      ...opts,
-    };
-    return new DrTrace(merged);
-  }
-
-  attachToConsole(): void {
-    if (!this.enabled) return;
-    this.logger.attachToConsole();
-  }
-
-  detachFromConsole(): void {
-    this.logger.detachFromConsole();
-  }
-
-  log(message: string, level: LogLevel = 'info', context?: Record<string, unknown>): void {
-    if (!this.enabled) return;
-    this.logger.log(level, message, context);
-  }
-
-  error(message: string, context?: Record<string, unknown>): void {
-    if (!this.enabled) return;
-    this.logger.log('error', message, context);
-  }
-
-  async shutdown(): Promise<void> {
-    await this.queue.flush();
-    this.queue.stop();
-    this.detachFromConsole();
-  }
-}

package/src/config-schema.ts

@@ -1,115 +0,0 @@
-/**
- * Configuration schema and validation for DrTrace projects.
- * Mirrors the Python config_schema.py implementation.
- */
-
-import * as fs from "fs";
-import * as path from "path";
-
-export interface DrTraceConfig {
-  project_name: string;
-  application_id: string;
-  language?: "python" | "javascript" | "both";
-  daemon_url?: string;
-  enabled?: boolean;
-  environments?: string[];
-  agent?: {
-    enabled?: boolean;
-    framework?: "bmad" | "langchain" | "other";
-  };
-  created_at?: string;
-}
-
-export class ConfigSchema {
-  private static VALID_ENVIRONMENTS = [
-    "development",
-    "staging",
-    "production",
-    "ci",
-  ];
-
-  /**
-   * Get default configuration with provided values
-   */
-  static getDefaultConfig(options: {
-    project_name: string;
-    application_id: string;
-    language?: "python" | "javascript" | "both";
-    daemon_url?: string;
-    enabled?: boolean;
-    environments?: string[];
-    agent_enabled?: boolean;
-    agent_framework?: "bmad" | "langchain" | "other";
-  }): DrTraceConfig {
-    return {
-      project_name: options.project_name,
-      application_id: options.application_id,
-      language: options.language || "javascript",
-      daemon_url: options.daemon_url || "http://localhost:8001",
-      enabled: options.enabled !== false,
-      environments: options.environments || ["development"],
-      agent: {
-        enabled: options.agent_enabled || false,
-        framework: options.agent_framework || "bmad",
-      },
-      created_at: new Date().toISOString(),
-    };
-  }
-
-  /**
-   * Validate configuration against schema
-   */
-  static validate(config: DrTraceConfig): boolean {
-    // Required fields
-    if (!config.project_name || typeof config.project_name !== "string") {
-      throw new Error("Missing required field: project_name");
-    }
-    if (!config.application_id || typeof config.application_id !== "string") {
-      throw new Error("Missing required field: application_id");
-    }
-
-    // Type validation
-    if (config.enabled !== undefined && typeof config.enabled !== "boolean") {
-      throw new Error("Field 'enabled' must be boolean");
-    }
-
-    // Environment validation
-    if (config.environments) {
-      if (!Array.isArray(config.environments)) {
-        throw new Error("Field 'environments' must be an array");
-      }
-      for (const env of config.environments) {
-        if (!this.VALID_ENVIRONMENTS.includes(env)) {
-          throw new Error(`Invalid environment: ${env}`);
-        }
-      }
-    }
-
-    return true;
-  }
-
-  /**
-   * Save configuration to file
-   */
-  static save(config: DrTraceConfig, filePath: string): void {
-    this.validate(config);
-    const dir = path.dirname(filePath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    fs.writeFileSync(filePath, JSON.stringify(config, null, 2));
-  }
-
-  /**
-   * Load configuration from file
-   */
-  static load(filePath: string): DrTraceConfig {
-    if (!fs.existsSync(filePath)) {
-      throw new Error(`Config file not found: ${filePath}`);
-    }
-    const content = fs.readFileSync(filePath, "utf-8");
-    const config = JSON.parse(content);
-    this.validate(config);
-    return config;
-  }
-}

package/src/config.ts

@@ -1,326 +0,0 @@
-/**
- * Configuration loading and management for DrTrace JavaScript client.
- *
- * Implements hierarchical config loading with the following priority:
- * 1. Environment variables (highest)
- * 2. _drtrace/config.json (per-project)
- * 3. _drtrace/config.{NODE_ENV}.json (environment-specific overrides)
- * 4. Default values (lowest)
- *
- * Usage:
- * ```typescript
- * import { ConfigLoader } from './config';
- * const config = ConfigLoader.load({ projectRoot: '.', environment: 'production' });
- * console.log(config.drtrace.applicationId);
- * ```
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-
-/**
- * DrTrace Configuration interface
- */
-export interface DrTraceConfig {
-  project: {
-    name: string;
-    language?: string;
-    description?: string;
-  };
-  drtrace: {
-    applicationId: string;
-    daemonUrl?: string;
-    enabled?: boolean;
-    logLevel?: 'debug' | 'info' | 'warn' | 'error';
-    batchSize?: number;
-    flushIntervalMs?: number;
-    retentionDays?: number;
-  };
-  agent?: {
-    enabled?: boolean;
-    agentFile?: string | null;
-    framework?: 'bmad' | 'langchain' | 'other' | null;
-  };
-  environment?: {
-    [key: string]: Partial<DrTraceConfig>;
-  };
-}
-
-/**
- * Schema validation and defaults for DrTrace configuration.
- */
-export class ConfigSchema {
-  /**
-   * Default configuration values
-   */
-  static readonly DEFAULTS: DrTraceConfig = {
-    project: {
-      name: 'my-app',
-      language: 'javascript',
-      description: 'My application',
-    },
-    drtrace: {
-      applicationId: 'my-app',
-      daemonUrl: 'http://localhost:8001',
-      enabled: true,
-      logLevel: 'info',
-      batchSize: 50,
-      flushIntervalMs: 1000,
-      retentionDays: 7,
-    },
-    agent: {
-      enabled: false,
-      agentFile: null,
-      framework: null,
-    },
-    environment: {},
-  };
-
-  /**
-   * Validate configuration against schema.
-   *
-   * @param config - Configuration to validate
-   * @returns Validated configuration
-   * @throws Error if validation fails
-   */
-  static validate(config: any): DrTraceConfig {
-    const errors: string[] = [];
-
-    // Check for required sections
-    if (!config.project) {
-      errors.push('Missing required section: project');
-    } else {
-      if (!config.project.name) {
-        errors.push('Missing required field: project.name');
-      }
-      if (typeof config.project.name !== 'string' && config.project.name !== undefined) {
-        errors.push(`Invalid type for project.name: expected string, got ${typeof config.project.name}`);
-      }
-    }
-
-    if (!config.drtrace) {
-      errors.push('Missing required section: drtrace');
-    } else {
-      if (!config.drtrace.applicationId) {
-        errors.push('Missing required field: drtrace.applicationId');
-      }
-      if (typeof config.drtrace.applicationId !== 'string' && config.drtrace.applicationId !== undefined) {
-        errors.push(
-          `Invalid type for drtrace.applicationId: expected string, got ${typeof config.drtrace.applicationId}`
-        );
-      }
-    }
-
-    // Validate enums
-    if (config.drtrace?.logLevel) {
-      const validLevels = ['debug', 'info', 'warn', 'error'];
-      if (!validLevels.includes(config.drtrace.logLevel)) {
-        errors.push(
-          `Invalid logLevel: ${config.drtrace.logLevel}. Must be one of: ${validLevels.join(', ')}`
-        );
-      }
-    }
-
-    if (config.agent?.framework) {
-      const validFrameworks = ['bmad', 'langchain', 'other'];
-      if (!validFrameworks.includes(config.agent.framework)) {
-        errors.push(
-          `Invalid agent framework: ${config.agent.framework}. Must be one of: ${validFrameworks.join(', ')}`
-        );
-      }
-    }
-
-    // Validate types
-    if (config.drtrace?.enabled !== undefined && typeof config.drtrace.enabled !== 'boolean') {
-      errors.push(`Invalid type for drtrace.enabled: expected boolean, got ${typeof config.drtrace.enabled}`);
-    }
-
-    if (config.drtrace?.batchSize !== undefined && typeof config.drtrace.batchSize !== 'number') {
-      errors.push(`Invalid type for drtrace.batchSize: expected number, got ${typeof config.drtrace.batchSize}`);
-    }
-
-    if (config.drtrace?.flushIntervalMs !== undefined && typeof config.drtrace.flushIntervalMs !== 'number') {
-      errors.push(
-        `Invalid type for drtrace.flushIntervalMs: expected number, got ${typeof config.drtrace.flushIntervalMs}`
-      );
-    }
-
-    if (config.drtrace?.retentionDays !== undefined && typeof config.drtrace.retentionDays !== 'number') {
-      errors.push(`Invalid type for drtrace.retentionDays: expected number, got ${typeof config.drtrace.retentionDays}`);
-    }
-
-    if (errors.length > 0) {
-      throw new Error(`Configuration validation failed:\n${errors.join('\n')}`);
-    }
-
-    return config as DrTraceConfig;
-  }
-
-  /**
-   * Get default configuration
-   */
-  static getDefault(): DrTraceConfig {
-    return JSON.parse(JSON.stringify(ConfigSchema.DEFAULTS));
-  }
-}
-
-/**
- * Configuration loading and merging utility
- */
-export class ConfigLoader {
-  /**
-   * Load configuration with hierarchical merging.
-   *
-   * Priority (highest to lowest):
-   * 1. Environment variables (process.env with DRTRACE_* prefix)
-   * 2. _drtrace/config.json
-   * 3. _drtrace/config.{environment}.json
-   * 4. Default values
-   *
-   * @param options - Loading options
-   * @returns Loaded and validated configuration
-   */
-  static load(options: { projectRoot?: string; environment?: string } = {}): DrTraceConfig {
-    const projectRoot = options.projectRoot || '.';
-    const configDir = path.join(projectRoot, '_drtrace');
-
-    // Start with defaults
-    let config = ConfigSchema.getDefault();
-
-    // Determine environment
-    let environment = options.environment;
-    if (!environment) {
-      environment = process.env.NODE_ENV || process.env.PYTHON_ENV || undefined;
-    }
-
-    // Load base config from _drtrace/config.json
-    const baseConfigPath = path.join(configDir, 'config.json');
-    if (fs.existsSync(baseConfigPath)) {
-      const baseConfig = ConfigLoader.loadJsonFile(baseConfigPath);
-      config = ConfigLoader.mergeConfigs(config, baseConfig);
-    }
-
-    // Load environment-specific overrides
-    if (environment) {
-      // First, check for environment-specific subsection in base config
-      if (config.environment && environment in config.environment) {
-        config = ConfigLoader.mergeConfigs(config, {
-          drtrace: config.environment[environment],
-        } as any);
-      }
-
-      // Then, load environment-specific config file (takes precedence)
-      const envConfigPath = path.join(configDir, `config.${environment}.json`);
-      if (fs.existsSync(envConfigPath)) {
-        const envConfig = ConfigLoader.loadJsonFile(envConfigPath);
-        config = ConfigLoader.mergeConfigs(config, envConfig);
-      }
-    }
-
-    // Apply environment variable overrides (highest priority)
-    config = ConfigLoader.applyEnvVarOverrides(config);
-
-    // Validate final configuration
-    config = ConfigSchema.validate(config);
-
-    return config;
-  }
-
-  /**
-   * Load and parse JSON file
-   */
-  private static loadJsonFile(filepath: string): any {
-    try {
-      const content = fs.readFileSync(filepath, 'utf-8');
-      return JSON.parse(content);
-    } catch (error: any) {
-      if (error instanceof SyntaxError) {
-        throw new Error(`Invalid JSON in ${filepath}: ${error.message}`);
-      }
-      throw new Error(`Error reading ${filepath}: ${error.message}`);
-    }
-  }
-
-  /**
-   * Deep merge override config into base config
-   */
-  private static mergeConfigs(base: any, overrides: any): any {
-    const result = JSON.parse(JSON.stringify(base)); // Deep copy
-
-    for (const key in overrides) {
-      if (Object.prototype.hasOwnProperty.call(overrides, key)) {
-        const value = overrides[key];
-        if (
-          result[key] &&
-          typeof result[key] === 'object' &&
-          !Array.isArray(result[key]) &&
-          typeof value === 'object' &&
-          !Array.isArray(value)
-        ) {
-          result[key] = ConfigLoader.mergeConfigs(result[key], value);
-        } else {
-          result[key] = value;
-        }
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * Apply environment variable overrides to config.
-   *
-   * Environment variables use DRTRACE_* prefix with UPPER_SNAKE_CASE.
-   * Examples:
-  *   - DRTRACE_APPLICATION_ID -> config.drtrace.applicationId
-  *   - DRTRACE_DAEMON_URL -> config.drtrace.daemonUrl
-  *   - DRTRACE_ENABLED -> config.drtrace.enabled
-   */
-  private static applyEnvVarOverrides(config: any): any {
-    const result = JSON.parse(JSON.stringify(config)); // Deep copy
-
-    const envVarMappings: Record<string, [string, string]> = {
-      DRTRACE_APPLICATION_ID: ['drtrace', 'applicationId'],
-      DRTRACE_DAEMON_URL: ['drtrace', 'daemonUrl'],
-      DRTRACE_ENABLED: ['drtrace', 'enabled'],
-      DRTRACE_LOG_LEVEL: ['drtrace', 'logLevel'],
-      DRTRACE_BATCH_SIZE: ['drtrace', 'batchSize'],
-      DRTRACE_FLUSH_INTERVAL_MS: ['drtrace', 'flushIntervalMs'],
-      DRTRACE_RETENTION_DAYS: ['drtrace', 'retentionDays'],
-      DRTRACE_AGENT_ENABLED: ['agent', 'enabled'],
-      DRTRACE_AGENT_FILE: ['agent', 'agentFile'],
-      DRTRACE_AGENT_FRAMEWORK: ['agent', 'framework'],
-    };
-
-    for (const [envVar, [section, field]] of Object.entries(envVarMappings)) {
-      if (process.env[envVar]) {
-        let value: any = process.env[envVar];
-
-        // Type conversions
-        if (field === 'enabled') {
-          value = ['true', '1', 'yes'].includes(value.toLowerCase());
-        } else if (['batchSize', 'flushIntervalMs', 'retentionDays'].includes(field)) {
-          const parsed = parseInt(value, 10);
-          if (isNaN(parsed)) {
-            throw new Error(`Invalid value for ${envVar}: must be an integer`);
-          }
-          value = parsed;
-        }
-
-        if (!result[section]) {
-          result[section] = {};
-        }
-        result[section][field] = value;
-      }
-    }
-
-    return result;
-  }
-}
-
-/**
- * Convenience function to load configuration
- */
-export function loadConfig(options?: { projectRoot?: string; environment?: string }): DrTraceConfig {
-  return ConfigLoader.load(options);
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export { DrTrace } from './client';
-export { loadConfig } from './config';
-export * from './types';