vectra-js 0.9.3 → 0.9.5

package/src/dashboard/trace-script.js

@@ -0,0 +1,184 @@
+document.addEventListener('DOMContentLoaded', () => {
+    const urlParams = new URLSearchParams(window.location.search);
+    const traceId = urlParams.get('id');
+
+    if (!traceId) {
+        alert('No trace ID provided');
+        window.location.href = '/dashboard/';
+        return;
+    }
+
+    loadTraceDetails(traceId);
+});
+
+async function loadTraceDetails(traceId) {
+    try {
+        const res = await fetch(`/api/observability/traces/${traceId}`);
+        if (!res.ok) throw new Error('Failed to fetch trace details');
+        
+        const trace = await res.json();
+        if (!trace || trace.length === 0) {
+            document.getElementById('loading').innerHTML = '<div class="text-red-500">Trace not found</div>';
+            return;
+        }
+
+        renderTrace(trace);
+    } catch (e) {
+        console.error(e);
+        document.getElementById('loading').innerHTML = `<div class="text-red-500">Error: ${e.message}</div>`;
+    }
+}
+
+function renderTrace(trace) {
+    const content = document.getElementById('trace-content');
+    const loading = document.getElementById('loading');
+    
+    // Sort spans by start time
+    trace.sort((a, b) => a.start_time - b.start_time);
+    
+    const root = trace.find(s => !s.parent_span_id) || trace[0];
+    const startTime = root.start_time;
+    const endTime = Math.max(...trace.map(s => s.end_time));
+    const totalDuration = endTime - startTime;
+
+    // Header Info
+    document.getElementById('header-trace-id').textContent = root.trace_id;
+    document.getElementById('trace-timestamp').textContent = new Date(root.start_time).toLocaleString();
+    document.getElementById('trace-duration').textContent = `${totalDuration}ms`;
+    
+    const modelInfo = root.model_name ? `${root.provider}/${root.model_name}` : (root.provider || '-');
+    document.getElementById('trace-model').textContent = modelInfo;
+
+    const hasError = trace.some(s => s.error && s.error !== '{}');
+    const statusEl = document.getElementById('trace-status');
+    if (hasError) {
+        statusEl.className = 'px-3 py-1 rounded-full text-sm font-semibold bg-red-100 text-red-700 dark:bg-red-900/30 dark:text-red-400';
+        statusEl.textContent = 'Error';
+    } else {
+        statusEl.className = 'px-3 py-1 rounded-full text-sm font-semibold bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400';
+        statusEl.textContent = 'Success';
+    }
+
+    // Render Timeline
+    const timelineContainer = document.getElementById('timeline-container');
+    timelineContainer.innerHTML = '';
+    
+    trace.forEach(span => {
+        const left = ((span.start_time - startTime) / totalDuration) * 100;
+        const width = Math.max(((span.end_time - span.start_time) / totalDuration) * 100, 0.5); // min width 0.5%
+        
+        const row = document.createElement('div');
+        row.className = 'relative group h-8 flex items-center';
+        row.innerHTML = `
+            <div class="w-1/4 min-w-[150px] text-xs font-medium text-slate-600 dark:text-slate-400 truncate pr-4" title="${span.name}">
+                ${span.name}
+            </div>
+            <div class="flex-1 h-full relative">
+                <div class="absolute top-1/2 -translate-y-1/2 h-4 bg-brand-500/20 dark:bg-brand-500/10 rounded-sm border border-brand-500/40 dark:border-brand-500/20 hover:bg-brand-500/40 dark:hover:bg-brand-500/30 transition-colors cursor-pointer"
+                     style="left: ${left}%; width: ${width}%"
+                     onclick="scrollToSpan('${span.span_id}')">
+                </div>
+                <div class="absolute top-1/2 -translate-y-1/2 text-[10px] text-slate-400 dark:text-slate-500 ml-2 pointer-events-none" style="left: ${left + width}%">
+                    ${span.end_time - span.start_time}ms
+                </div>
+            </div>
+        `;
+        timelineContainer.appendChild(row);
+    });
+
+    // Render Detailed Spans
+    const spansList = document.getElementById('spans-list');
+    spansList.innerHTML = '';
+
+    trace.forEach(span => {
+        const card = document.createElement('div');
+        card.id = `span-${span.span_id}`;
+        card.className = 'bg-white dark:bg-dark-900 rounded-lg border border-slate-200 dark:border-white/5 shadow-sm overflow-hidden transition-colors duration-200';
+        
+        const isError = span.error && span.error !== '{}';
+        const borderColor = isError ? 'border-l-4 border-l-red-500' : 'border-l-4 border-l-brand-500';
+        
+        card.innerHTML = `
+            <div class="px-6 py-4 bg-slate-50 dark:bg-white/5 border-b border-slate-100 dark:border-white/5 flex justify-between items-center ${borderColor}">
+                <div>
+                    <h4 class="text-sm font-bold text-slate-900 dark:text-white font-mono">${span.name}</h4>
+                    <div class="text-xs text-slate-500 dark:text-slate-400 mt-1 font-mono">${span.span_id}</div>
+                </div>
+                <div class="text-right">
+                    <div class="text-sm font-semibold text-slate-700 dark:text-slate-200">${span.end_time - span.start_time}ms</div>
+                    <div class="text-xs text-slate-400 dark:text-slate-500">${new Date(span.start_time).toLocaleTimeString()}</div>
+                </div>
+            </div>
+            <div class="p-6 space-y-4">
+                ${renderJSONSection('Input', span.input)}
+                ${renderJSONSection('Output', span.output)}
+                ${renderJSONSection('Attributes', span.attributes)}
+                ${isError ? renderJSONSection('Error', span.error, true) : ''}
+            </div>
+        `;
+        spansList.appendChild(card);
+    });
+
+    loading.classList.add('hidden');
+    content.classList.remove('hidden');
+    lucide.createIcons();
+}
+
+function renderJSONSection(title, data, isError = false) {
+    if (!data || data === '{}') return '';
+    
+    let parsed = data;
+    if (typeof data === 'string') {
+        try {
+            parsed = JSON.parse(data);
+        } catch (e) {
+            parsed = data; // Keep as string if parsing fails
+        }
+    }
+
+    if (Object.keys(parsed).length === 0) return '';
+
+    const jsonHtml = syntaxHighlight(parsed);
+    const bgClass = isError ? 'bg-red-50 dark:bg-red-900/10' : 'bg-slate-900 dark:bg-black';
+    const textClass = isError ? 'text-red-900 dark:text-red-200' : 'text-slate-50 dark:text-slate-300';
+
+    return `
+        <div>
+            <h5 class="text-xs font-semibold text-slate-500 dark:text-slate-400 uppercase tracking-wider mb-2">${title}</h5>
+            <div class="${bgClass} rounded-lg p-4 overflow-x-auto">
+                <pre class="text-xs font-mono ${textClass}"><code>${jsonHtml}</code></pre>
+            </div>
+        </div>
+    `;
+}
+
+function syntaxHighlight(json) {
+    if (typeof json !== 'string') {
+        json = JSON.stringify(json, null, 2);
+    }
+    json = json.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    return json.replace(/("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?)/g, function (match) {
+        let cls = 'text-purple-300'; // number
+        if (/^"/.test(match)) {
+            if (/:$/.test(match)) {
+                cls = 'text-indigo-300'; // key
+            } else {
+                cls = 'text-green-300'; // string
+            }
+        } else if (/true|false/.test(match)) {
+            cls = 'text-blue-300'; // boolean
+        } else if (/null/.test(match)) {
+            cls = 'text-slate-400'; // null
+        }
+        return '<span class="' + cls + '">' + match + '</span>';
+    });
+}
+
+function scrollToSpan(spanId) {
+    const el = document.getElementById(`span-${spanId}`);
+    if (el) {
+        el.scrollIntoView({ behavior: 'smooth', block: 'center' });
+        el.classList.add('ring-2', 'ring-brand-500', 'ring-offset-2');
+        setTimeout(() => el.classList.remove('ring-2', 'ring-brand-500', 'ring-offset-2'), 2000);
+    }
+}

package/src/dashboard/trace.html

@@ -0,0 +1,239 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Trace Details - Vectra Dashboard</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script>
+        tailwind.config = {
+            darkMode: 'class',
+            theme: {
+                extend: {
+                    colors: {
+                        brand: {
+                            50: '#f5f3ff',
+                            100: '#ede9fe',
+                            200: '#ddd6fe',
+                            300: '#c4b5fd',
+                            400: '#a78bfa',
+                            500: '#8b5cf6',
+                            600: '#7c3aed',
+                            700: '#6d28d9',
+                            800: '#5b21b6',
+                            900: '#4c1d95',
+                            950: '#2e1065',
+                        },
+                        dark: {
+                            950: '#020204',
+                            900: '#08080C',
+                            850: '#0F0F16',
+                            800: '#14141F',
+                            700: '#1C1C2E',
+                        }
+                    }
+                }
+            }
+        }
+
+        // Check for saved theme preference or use system preference
+        if (localStorage.getItem('color-theme') === 'dark' || (!('color-theme' in localStorage) && window.matchMedia('(prefers-color-scheme: dark)').matches)) {
+            document.documentElement.classList.add('dark');
+        } else {
+            document.documentElement.classList.remove('dark');
+        }
+    </script>
+    <script src="https://unpkg.com/lucide@latest"></script>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap" rel="stylesheet">
+    <style>
+        body { font-family: 'Inter', sans-serif; }
+        .sidebar-link.active { background-color: #f3f4f6; color: #111827; }
+        .dark .sidebar-link.active { background-color: rgba(255, 255, 255, 0.1); color: #ffffff; }
+        .sidebar-link:hover { background-color: #f9fafb; color: #111827; }
+        .dark .sidebar-link:hover { background-color: rgba(255, 255, 255, 0.05); color: #ffffff; }
+        
+        /* JSON Syntax Highlighting */
+        .json-key { color: #7c3aed; } /* violet-600 */
+        .dark .json-key { color: #a78bfa; } /* violet-400 */
+        .json-string { color: #059669; } /* emerald-600 */
+        .dark .json-string { color: #34d399; } /* emerald-400 */
+        .json-number { color: #d97706; } /* amber-600 */
+        .dark .json-number { color: #fbbf24; } /* amber-400 */
+        .json-boolean { color: #dc2626; } /* red-600 */
+        .dark .json-boolean { color: #f87171; } /* red-400 */
+        .json-null { color: #9ca3af; } /* gray-400 */
+        .dark .json-null { color: #9ca3af; } /* gray-400 */
+
+        /* Custom scrollbar for dark mode compatibility */
+        ::-webkit-scrollbar {
+            width: 8px;
+            height: 8px;
+        }
+        ::-webkit-scrollbar-track {
+            background: transparent;
+        }
+        ::-webkit-scrollbar-thumb {
+            background: #cbd5e1;
+            border-radius: 4px;
+        }
+        .dark ::-webkit-scrollbar-thumb {
+            background: #334155;
+        }
+        ::-webkit-scrollbar-thumb:hover {
+            background: #94a3b8;
+        }
+        .dark ::-webkit-scrollbar-thumb:hover {
+            background: #475569;
+        }
+    </style>
+</head>
+<body class="bg-gray-50 text-slate-800 dark:bg-dark-950 dark:text-white h-screen overflow-hidden flex transition-colors duration-200">
+
+    <!-- Sidebar -->
+    <aside class="w-64 bg-white border-r border-gray-200 dark:bg-dark-900 dark:border-white/5 flex-col hidden md:flex transition-colors duration-200">
+        <!-- Logo -->
+        <div class="h-16 flex items-center px-6 border-b border-gray-100 dark:border-white/5">
+            <div class="flex items-center gap-2">
+                <div class="bg-brand-600 p-1.5 rounded-lg text-white">
+                    <i data-lucide="layers" class="w-5 h-5"></i>
+                </div>
+                <span class="text-xl font-bold text-slate-900 dark:text-white tracking-tight">Vectra</span>
+            </div>
+        </div>
+
+        <!-- Navigation -->
+        <nav class="flex-1 px-4 py-6 space-y-1 overflow-y-auto">
+            <div class="mb-6">
+                <p class="px-2 text-xs font-semibold text-gray-400 dark:text-gray-500 uppercase tracking-wider mb-2">Menu</p>
+                <a href="/dashboard/" class="w-full flex items-center px-3 py-2 text-sm font-medium rounded-lg text-gray-600 dark:text-gray-400 sidebar-link group transition-colors">
+                    <i data-lucide="layout-dashboard" class="w-5 h-5 mr-3 text-gray-400 dark:text-gray-500 group-hover:text-gray-500 dark:group-hover:text-gray-300"></i>
+                    Dashboard
+                </a>
+                <a href="/dashboard/?view=traces" class="w-full flex items-center px-3 py-2 text-sm font-medium rounded-lg text-slate-900 dark:text-white bg-gray-100 dark:bg-white/10 sidebar-link active group transition-colors">
+                    <i data-lucide="activity" class="w-5 h-5 mr-3 text-gray-500 dark:text-gray-400"></i>
+                    Traces
+                </a>
+                <a href="/dashboard/?view=sessions" class="w-full flex items-center px-3 py-2 text-sm font-medium rounded-lg text-gray-600 dark:text-gray-400 sidebar-link group transition-colors">
+                    <i data-lucide="users" class="w-5 h-5 mr-3 text-gray-400 dark:text-gray-500 group-hover:text-gray-500 dark:group-hover:text-gray-300"></i>
+                    Sessions
+                </a>
+            </div>
+            
+            <div>
+                <p class="px-2 text-xs font-semibold text-gray-400 dark:text-gray-500 uppercase tracking-wider mb-2">Management</p>
+                <a href="#" class="w-full flex items-center px-3 py-2 text-sm font-medium rounded-lg text-gray-600 dark:text-gray-400 sidebar-link group transition-colors">
+                    <i data-lucide="settings" class="w-5 h-5 mr-3 text-gray-400 dark:text-gray-500 group-hover:text-gray-500 dark:group-hover:text-gray-300"></i>
+                    Settings
+                </a>
+                <a href="#" class="w-full flex items-center px-3 py-2 text-sm font-medium rounded-lg text-gray-600 dark:text-gray-400 sidebar-link group transition-colors">
+                    <i data-lucide="book-open" class="w-5 h-5 mr-3 text-gray-400 dark:text-gray-500 group-hover:text-gray-500 dark:group-hover:text-gray-300"></i>
+                    Documentation
+                </a>
+            </div>
+        </nav>
+
+        <!-- User Profile (Bottom) -->
+        <div class="p-4 border-t border-gray-100 dark:border-white/5">
+            <div class="flex items-center gap-3">
+                <div class="w-8 h-8 rounded-full bg-brand-100 dark:bg-brand-900/50 flex items-center justify-center text-brand-600 dark:text-brand-400 font-bold text-xs border border-brand-200 dark:border-brand-500/20">
+                    AD
+                </div>
+                <div>
+                    <p class="text-sm font-medium text-gray-900 dark:text-white">Admin User</p>
+                    <p class="text-xs text-gray-500">admin@vectra.ai</p>
+                </div>
+                <button onclick="toggleTheme()" class="ml-auto p-1.5 text-gray-400 hover:text-gray-600 dark:text-gray-500 dark:hover:text-gray-300 rounded-lg hover:bg-gray-100 dark:hover:bg-white/5 transition-colors">
+                     <i data-lucide="moon" class="w-4 h-4 hidden dark:block"></i>
+                     <i data-lucide="sun" class="w-4 h-4 block dark:hidden"></i>
+                </button>
+            </div>
+        </div>
+    </aside>
+
+    <!-- Main Content -->
+    <div class="flex-1 flex flex-col min-w-0 overflow-hidden bg-gray-50 dark:bg-dark-950 transition-colors duration-200">
+        
+        <!-- Top Header -->
+        <header class="bg-white dark:bg-dark-900 border-b border-gray-200 dark:border-white/5 h-16 flex items-center justify-between px-6 lg:px-8 transition-colors duration-200">
+            <div class="flex items-center flex-1">
+                <div class="flex items-center text-sm text-gray-500 dark:text-gray-400">
+                    <a href="/dashboard/" class="hover:text-gray-900 dark:hover:text-white transition-colors">Traces</a>
+                    <i data-lucide="chevron-right" class="w-4 h-4 mx-2"></i>
+                    <span class="font-medium text-gray-900 dark:text-white" id="header-trace-id">Loading...</span>
+                </div>
+            </div>
+            <div class="ml-4 flex items-center gap-4">
+                <button class="p-2 text-gray-400 hover:text-gray-500 dark:hover:text-white transition-colors">
+                    <i data-lucide="bell" class="w-6 h-6"></i>
+                </button>
+            </div>
+        </header>
+
+        <!-- Main Scrollable Area -->
+        <main class="flex-1 overflow-y-auto p-6 lg:p-8" id="main-content">
+            
+            <!-- Loading State -->
+            <div id="loading" class="flex flex-col justify-center items-center h-64">
+                <div class="animate-spin rounded-full h-8 w-8 border-b-2 border-brand-600 dark:border-brand-500 mb-4"></div>
+                <p class="text-sm text-gray-500 dark:text-gray-400">Loading trace details...</p>
+            </div>
+
+            <!-- Trace Content (Hidden initially) -->
+            <div id="trace-content" class="hidden space-y-8 max-w-7xl mx-auto">
+                
+                <!-- Header Card -->
+                <div class="bg-white dark:bg-dark-900 rounded-xl shadow-sm border border-gray-100 dark:border-white/5 p-6 transition-colors duration-200">
+                    <div class="flex flex-col md:flex-row justify-between items-start md:items-center mb-6 gap-4">
+                        <div>
+                            <h1 class="text-2xl font-bold text-gray-900 dark:text-white mb-1">Trace Summary</h1>
+                            <div class="flex items-center space-x-6 text-sm text-gray-500 dark:text-gray-400">
+                                <span class="flex items-center"><i data-lucide="calendar" class="w-4 h-4 mr-2 text-gray-400 dark:text-gray-500"></i> <span id="trace-timestamp">-</span></span>
+                                <span class="flex items-center"><i data-lucide="clock" class="w-4 h-4 mr-2 text-gray-400 dark:text-gray-500"></i> <span id="trace-duration">-</span></span>
+                                <span class="flex items-center"><i data-lucide="cpu" class="w-4 h-4 mr-2 text-gray-400 dark:text-gray-500"></i> <span id="trace-model">-</span></span>
+                            </div>
+                        </div>
+                        <div id="trace-status" class="px-4 py-1.5 rounded-full text-sm font-semibold bg-gray-100 text-gray-600 border border-gray-200 dark:bg-white/10 dark:text-gray-300 dark:border-white/10">
+                            Unknown
+                        </div>
+                    </div>
+
+                    <!-- Timeline / Gantt -->
+                    <div class="border-t border-gray-100 dark:border-white/5 pt-6">
+                        <h3 class="text-xs font-semibold text-gray-500 dark:text-gray-400 uppercase tracking-wider mb-4">Execution Timeline</h3>
+                        <div id="timeline-container" class="space-y-3 relative">
+                            <!-- Spans injected here -->
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Detailed Spans List -->
+                <div class="space-y-6">
+                    <div class="flex items-center justify-between">
+                        <h3 class="text-lg font-bold text-gray-900 dark:text-white">Span Details</h3>
+                        <div class="text-sm text-gray-500 dark:text-gray-400">Detailed breakdown of operations</div>
+                    </div>
+                    <div id="spans-list" class="space-y-6">
+                        <!-- Span Cards injected here -->
+                    </div>
+                </div>
+
+            </div>
+        </main>
+    </div>
+
+    <script src="trace-script.js"></script>
+    <script>
+        lucide.createIcons();
+
+        function toggleTheme() {
+            if (document.documentElement.classList.contains('dark')) {
+                document.documentElement.classList.remove('dark');
+                localStorage.setItem('color-theme', 'light');
+            } else {
+                document.documentElement.classList.add('dark');
+                localStorage.setItem('color-theme', 'dark');
+            }
+        }
+    </script>
+</body>
+</html>

package/src/observability.js

@@ -0,0 +1,226 @@
+const { v4: uuidv4 } = require('uuid');
+const path = require('path');
+
+class SQLiteLogger {
+  constructor(config) {
+    this.enabled = config.enabled;
+    if (!this.enabled) return;
+
+    this.projectId = config.projectId;
+    this.trackMetrics = config.trackMetrics;
+    this.trackTraces = config.trackTraces;
+    this.trackLogs = config.trackLogs;
+    this.sessionTracking = config.sessionTracking;
+
+    try {
+        const rawPath = config.sqlitePath || 'vectra-observability.db';
+        const dbPath = path.isAbsolute(rawPath) ? rawPath : path.resolve(process.cwd(), rawPath);
+        // Ensure directory exists
+        const dbDir = path.dirname(dbPath);
+        console.log(`[SQLiteLogger] dbPath: ${dbPath}, dbDir: ${dbDir}`);
+        
+        const fs = require('fs');
+        if (!fs.existsSync(dbDir)) {
+          console.log(`[SQLiteLogger] Creating directory: ${dbDir}`);
+          fs.mkdirSync(dbDir, { recursive: true });
+        } else {
+          console.log(`[SQLiteLogger] Directory exists: ${dbDir}`);
+        }
+
+        const sqlite3 = require('sqlite3').verbose();
+        this.db = new sqlite3.Database(dbPath, (err) => {
+            if (err) {
+                console.error('Failed to connect to SQLite database:', err);
+                throw err;
+            }
+        });
+        this.initializeSchema();
+    } catch (error) {
+        console.error('Failed to initialize SQLite logger:', error);
+        throw error;
+    }
+  }
+
+  initializeSchema() {
+    this.db.serialize(() => {
+        this.db.run(`
+            CREATE TABLE IF NOT EXISTS traces (
+                id TEXT PRIMARY KEY,
+                project_id TEXT,
+                trace_id TEXT,
+                span_id TEXT,
+                parent_span_id TEXT,
+                name TEXT,
+                start_time INTEGER,
+                end_time INTEGER,
+                duration INTEGER,
+                status TEXT,
+                attributes TEXT, -- JSON
+                input TEXT, -- JSON
+                output TEXT, -- JSON
+                error TEXT, -- JSON
+                provider TEXT,
+                model_name TEXT
+            )
+        `);
+
+        // Attempt to add columns if they don't exist (migration)
+        this.db.run(`ALTER TABLE traces ADD COLUMN provider TEXT`, () => {});
+        this.db.run(`ALTER TABLE traces ADD COLUMN model_name TEXT`, () => {});
+
+        this.db.run(`
+            CREATE TABLE IF NOT EXISTS metrics (
+                id TEXT PRIMARY KEY,
+                project_id TEXT,
+                name TEXT,
+                value REAL,
+                timestamp INTEGER,
+                tags TEXT -- JSON
+            )
+        `);
+
+        this.db.run(`
+            CREATE TABLE IF NOT EXISTS logs (
+                id TEXT PRIMARY KEY,
+                project_id TEXT,
+                level TEXT,
+                message TEXT,
+                timestamp INTEGER,
+                context TEXT -- JSON
+            )
+        `);
+
+        this.db.run(`
+            CREATE TABLE IF NOT EXISTS sessions (
+                id TEXT PRIMARY KEY,
+                project_id TEXT,
+                session_id TEXT,
+                user_id TEXT,
+                start_time INTEGER,
+                last_activity_time INTEGER,
+                metadata TEXT -- JSON
+            )
+        `);
+    });
+  }
+
+  logTrace(trace) {
+    if (!this.enabled || !this.trackTraces) return;
+    try {
+      const stmt = this.db.prepare(`
+        INSERT INTO traces (id, project_id, trace_id, span_id, parent_span_id, name, start_time, end_time, duration, status, attributes, input, output, error, provider, model_name)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      stmt.run(
+        uuidv4(),
+        this.projectId,
+        trace.traceId,
+        trace.spanId,
+        trace.parentSpanId || null,
+        trace.name,
+        trace.startTime,
+        trace.endTime,
+        trace.duration,
+        trace.status,
+        JSON.stringify(trace.attributes || {}),
+        JSON.stringify(trace.input || {}),
+        JSON.stringify(trace.output || {}),
+        JSON.stringify(trace.error || {}),
+        trace.provider || null,
+        trace.modelName || null
+      );
+      stmt.finalize();
+    } catch (error) {
+      console.error('Failed to log trace:', error);
+    }
+  }
+
+  logMetric(nameOrObj, value, tags = {}) {
+    if (!this.enabled || !this.trackMetrics) return;
+    
+    let metricName = nameOrObj;
+    let metricValue = value;
+    let metricTags = tags;
+
+    if (typeof nameOrObj === 'object' && nameOrObj !== null) {
+        metricName = nameOrObj.name;
+        metricValue = nameOrObj.value;
+        metricTags = nameOrObj.tags || {};
+    }
+
+    try {
+      const stmt = this.db.prepare(`
+        INSERT INTO metrics (id, project_id, name, value, timestamp, tags)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `);
+      stmt.run(
+        uuidv4(),
+        this.projectId,
+        metricName,
+        metricValue,
+        Date.now(),
+        JSON.stringify(metricTags)
+      );
+      stmt.finalize();
+    } catch (error) {
+      console.error('Failed to log metric:', error);
+    }
+  }
+
+  log(level, message, context = {}) {
+    if (!this.enabled || !this.trackLogs) return;
+    try {
+      const stmt = this.db.prepare(`
+        INSERT INTO logs (id, project_id, level, message, timestamp, context)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `);
+      stmt.run(
+        uuidv4(),
+        this.projectId,
+        level,
+        message,
+        Date.now(),
+        JSON.stringify(context)
+      );
+      stmt.finalize();
+    } catch (error) {
+      console.error('Failed to log message:', error);
+    }
+  }
+
+  logSession(sessionId, userId, metadata = {}) {
+      if (!this.enabled || !this.sessionTracking) return;
+      try {
+          // Check if session exists (upsert logic if needed, but here simple insert/update)
+          // For simplicity, we just insert or ignore, or update last_activity
+          // Since sqlite3 doesn't support UPSERT in older versions easily without ON CONFLICT, let's try INSERT OR REPLACE
+          const stmt = this.db.prepare(`
+            INSERT OR REPLACE INTO sessions (id, project_id, session_id, user_id, start_time, last_activity_time, metadata)
+            VALUES (
+                COALESCE((SELECT id FROM sessions WHERE session_id = ?), ?),
+                ?, ?, ?, 
+                COALESCE((SELECT start_time FROM sessions WHERE session_id = ?), ?),
+                ?, ?
+            )
+          `);
+          
+          const now = Date.now();
+          const newId = uuidv4();
+          
+          stmt.run(
+              sessionId, newId,
+              this.projectId,
+              sessionId,
+              userId,
+              sessionId, now,
+              now,
+              JSON.stringify(metadata)
+          );
+          stmt.finalize();
+      } catch (error) {
+          console.error('Failed to log session:', error);
+      }
+  }
+}
+
+module.exports = SQLiteLogger;

package/src/processor.js

@@ -39,7 +39,7 @@ class DocumentProcessor {
   async process(text) {
     return this.config.strategy === ChunkingStrategy.AGENTIC 
       ? this.agenticSplit(text) 
-      : this.recursiveSplit(text);
+      : this.recursiveSplit(text);  
   }
 
   recursiveSplit(text) {