@loghead/core 0.1.18 → 0.1.19

package/dist/api/server.js

@@ -17,6 +17,90 @@ async function startApiServer(db) {
     await auth.initialize();
     console.log(chalk_1.default.bold.green(`\n💻 MCP server running on:`));
     console.log(chalk_1.default.green(`http://localhost:${port}`));
+    // Helper to parse OTLP attributes
+    const parseOtlpAttributes = (attributes) => {
+        if (!Array.isArray(attributes))
+            return {};
+        const result = {};
+        for (const attr of attributes) {
+            if (attr.key && attr.value) {
+                // Extract value based on type (stringValue, intValue, boolValue, etc.)
+                const val = attr.value;
+                if (val.stringValue !== undefined)
+                    result[attr.key] = val.stringValue;
+                else if (val.intValue !== undefined)
+                    result[attr.key] = parseInt(val.intValue);
+                else if (val.doubleValue !== undefined)
+                    result[attr.key] = val.doubleValue;
+                else if (val.boolValue !== undefined)
+                    result[attr.key] = val.boolValue;
+                else if (val.arrayValue !== undefined)
+                    result[attr.key] = val.arrayValue; // Simplified
+                else if (val.kvlistValue !== undefined)
+                    result[attr.key] = val.kvlistValue; // Simplified
+                else
+                    result[attr.key] = val;
+            }
+        }
+        return result;
+    };
+    // OTLP Logs Ingestion Endpoint
+    app.post("/v1/logs", async (req, res) => {
+        try {
+            const authHeader = req.headers.authorization;
+            if (!authHeader || !authHeader.startsWith("Bearer ")) {
+                return res.status(401).json({ code: 16, message: "Unauthenticated" });
+            }
+            const token = authHeader.split(" ")[1];
+            const payload = await auth.verifyToken(token);
+            if (!payload || !payload.streamId) {
+                return res.status(401).json({ code: 16, message: "Invalid token" });
+            }
+            const streamId = payload.streamId;
+            const { resourceLogs } = req.body;
+            if (!resourceLogs || !Array.isArray(resourceLogs)) {
+                return res.status(400).json({ code: 3, message: "Invalid payload" });
+            }
+            let count = 0;
+            for (const resourceLog of resourceLogs) {
+                const resourceAttrs = parseOtlpAttributes(resourceLog.resource?.attributes);
+                if (resourceLog.scopeLogs) {
+                    for (const scopeLog of resourceLog.scopeLogs) {
+                        const scopeName = scopeLog.scope?.name;
+                        if (scopeLog.logRecords) {
+                            for (const log of scopeLog.logRecords) {
+                                let content = "";
+                                if (log.body?.stringValue)
+                                    content = log.body.stringValue;
+                                else if (log.body?.kvlistValue)
+                                    content = JSON.stringify(log.body.kvlistValue);
+                                else if (typeof log.body === 'string')
+                                    content = log.body; // Fallback
+                                const logAttrs = parseOtlpAttributes(log.attributes);
+                                // Merge attributes: Resource > Scope (if any) > Log
+                                const metadata = {
+                                    ...resourceAttrs,
+                                    ...logAttrs,
+                                    severity: log.severityText || log.severityNumber,
+                                    scope: scopeName,
+                                    timestamp: log.timeUnixNano
+                                };
+                                if (content) {
+                                    await db.addLog(streamId, content, metadata);
+                                    count++;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            res.json({ partialSuccess: {}, logsIngested: count });
+        }
+        catch (e) {
+            console.error("OTLP Ingest error:", e);
+            res.status(500).json({ code: 13, message: String(e) });
+        }
+    });
     app.post("/api/ingest", async (req, res) => {
         try {
             const authHeader = req.headers.authorization;

package/dist/ui/main.js

@@ -94,7 +94,7 @@ async function startTui(db, token) {
                         type: "list",
                         name: "type",
                         message: "Stream type:",
-                        choices: ["browser", "terminal", "docker"],
+                        choices: ["browser", "terminal", "docker", "opentelemetry"],
                         prefix: "💡"
                     }
                 ]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loghead/core",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "Core API and Database for Loghead",
   "repository": {
     "type": "git",

package/src/api/server.ts

@@ -18,6 +18,90 @@ export async function startApiServer(db: DbService) {
     console.log(chalk.bold.green(`\n💻 MCP server running on:`));
     console.log(chalk.green(`http://localhost:${port}`));
 
+    // Helper to parse OTLP attributes
+    const parseOtlpAttributes = (attributes: any[]) => {
+        if (!Array.isArray(attributes)) return {};
+        const result: Record<string, any> = {};
+        for (const attr of attributes) {
+            if (attr.key && attr.value) {
+                // Extract value based on type (stringValue, intValue, boolValue, etc.)
+                const val = attr.value;
+                if (val.stringValue !== undefined) result[attr.key] = val.stringValue;
+                else if (val.intValue !== undefined) result[attr.key] = parseInt(val.intValue);
+                else if (val.doubleValue !== undefined) result[attr.key] = val.doubleValue;
+                else if (val.boolValue !== undefined) result[attr.key] = val.boolValue;
+                else if (val.arrayValue !== undefined) result[attr.key] = val.arrayValue; // Simplified
+                else if (val.kvlistValue !== undefined) result[attr.key] = val.kvlistValue; // Simplified
+                else result[attr.key] = val;
+            }
+        }
+        return result;
+    };
+
+    // OTLP Logs Ingestion Endpoint
+    app.post("/v1/logs", async (req, res) => {
+        try {
+            const authHeader = req.headers.authorization;
+            if (!authHeader || !authHeader.startsWith("Bearer ")) {
+                return res.status(401).json({ code: 16, message: "Unauthenticated" });
+            }
+            const token = authHeader.split(" ")[1];
+            const payload = await auth.verifyToken(token);
+            if (!payload || !payload.streamId) {
+                return res.status(401).json({ code: 16, message: "Invalid token" });
+            }
+
+            const streamId = payload.streamId;
+            const { resourceLogs } = req.body;
+
+            if (!resourceLogs || !Array.isArray(resourceLogs)) {
+                return res.status(400).json({ code: 3, message: "Invalid payload" });
+            }
+
+            let count = 0;
+
+            for (const resourceLog of resourceLogs) {
+                const resourceAttrs = parseOtlpAttributes(resourceLog.resource?.attributes);
+
+                if (resourceLog.scopeLogs) {
+                    for (const scopeLog of resourceLog.scopeLogs) {
+                        const scopeName = scopeLog.scope?.name;
+
+                        if (scopeLog.logRecords) {
+                            for (const log of scopeLog.logRecords) {
+                                let content = "";
+                                if (log.body?.stringValue) content = log.body.stringValue;
+                                else if (log.body?.kvlistValue) content = JSON.stringify(log.body.kvlistValue);
+                                else if (typeof log.body === 'string') content = log.body; // Fallback
+
+                                const logAttrs = parseOtlpAttributes(log.attributes);
+
+                                // Merge attributes: Resource > Scope (if any) > Log
+                                const metadata = {
+                                    ...resourceAttrs,
+                                    ...logAttrs,
+                                    severity: log.severityText || log.severityNumber,
+                                    scope: scopeName,
+                                    timestamp: log.timeUnixNano
+                                };
+
+                                if (content) {
+                                    await db.addLog(streamId, content, metadata);
+                                    count++;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            res.json({ partialSuccess: {}, logsIngested: count });
+        } catch (e) {
+            console.error("OTLP Ingest error:", e);
+            res.status(500).json({ code: 13, message: String(e) });
+        }
+    });
+
     app.post("/api/ingest", async (req, res) => {
         try {
             const authHeader = req.headers.authorization;

package/src/ui/main.ts

@@ -101,7 +101,7 @@ export async function startTui(db: DbService, token: string) {
                         type: "list",
                         name: "type",
                         message: "Stream type:",
-                        choices: ["browser", "terminal", "docker"],
+                        choices: ["browser", "terminal", "docker", "opentelemetry"],
                         prefix: "💡"
                     }
                 ]);

package/tests/embedding_perf.ts

@@ -0,0 +1,62 @@
+import { OllamaService } from "../src/services/ollama";
+import { performance } from "perf_hooks";
+
+async function runTest() {
+    console.log("Starting Embedding Performance Test...");
+
+    const service = new OllamaService();
+
+    // Ensure model exists first so pull time doesn't affect metrics
+    console.log("Checking model availability...");
+    await service.ensureModel();
+
+    const testString = "This is a test log message that simulates a typical log entry in a production system. It contains some details about an error or an event that occurred.";
+    const iterations = 10;
+    const latencies: number[] = [];
+
+    console.log(`Running ${iterations} iterations...`);
+
+    for (let i = 0; i < iterations; i++) {
+        const start = performance.now();
+        try {
+            await service.generateEmbedding(testString);
+            const end = performance.now();
+            const duration = end - start;
+            latencies.push(duration);
+            console.log(`Iteration ${i + 1}: ${duration.toFixed(2)}ms`);
+        } catch (e) {
+            console.error(`Iteration ${i + 1} failed:`, e);
+        }
+    }
+
+    if (latencies.length > 0) {
+        const warmUp = latencies[0];
+        const results = latencies.slice(1); // Remove warm-up
+
+        console.log("\n--- Results ---");
+        console.log(`Total Iterations: ${latencies.length}`);
+        console.log(`Warm-up Time: ${warmUp.toFixed(2)}ms`);
+
+        if (results.length > 0) {
+            const min = Math.min(...results);
+            const max = Math.max(...results);
+
+            // Calculate Median
+            results.sort((a, b) => a - b);
+            const mid = Math.floor(results.length / 2);
+            const median = results.length % 2 !== 0
+                ? results[mid]
+                : (results[mid - 1] + results[mid]) / 2;
+
+            console.log(`Min Latency (excl. warmup): ${min.toFixed(2)}ms`);
+            console.log(`Avg Latency (excl. warmup): ${median.toFixed(2)}ms`);
+            console.log(`Max Latency (excl. warmup): ${max.toFixed(2)}ms`);
+        } else {
+            console.log("Not enough iterations to calculate stats (need > 1).");
+        }
+    } else {
+        console.log("\nNo successful iterations.");
+    }
+}
+
+runTest().catch(console.error);