@loghead/core 0.1.33 → 0.1.35

package/dist/api/controllers.js

@@ -0,0 +1,106 @@
+// Helper to parse OTLP attributes
+export 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;
+};
+export async function ingestCustomLogs(body, token, db, auth) {
+    const payload = await auth.verifyToken(token);
+    if (!payload || !payload.streamId) {
+        throw new Error("Unauthorized: Invalid token");
+    }
+    const { streamId, logs } = body;
+    console.log(`[API] Ingesting logs for stream: ${streamId}`);
+    if (streamId !== payload.streamId) {
+        throw new Error("Forbidden: Token does not match streamId");
+    }
+    if (!logs) {
+        throw new Error("Missing logs");
+    }
+    const logEntries = Array.isArray(logs) ? logs : [logs];
+    console.log(`[API] Processing ${logEntries.length} log entries`);
+    for (const log of logEntries) {
+        let content = "";
+        let metadata = {};
+        if (typeof log === "string") {
+            content = log;
+        }
+        else if (typeof log === "object") {
+            content = log.content || JSON.stringify(log);
+            metadata = log.metadata || {};
+        }
+        if (content) {
+            await db.addLog(streamId, content, metadata);
+        }
+    }
+    console.log(`[API] /api/ingest Successfully added ${logEntries.length} logs`);
+    return { success: true, count: logEntries.length };
+}
+export async function ingestOtlpLogs(body, token, db, auth) {
+    const payload = await auth.verifyToken(token);
+    if (!payload || !payload.streamId) {
+        throw new Error("Unauthorized: Invalid token");
+    }
+    const streamId = payload.streamId;
+    console.log(`[API] Ingesting OTLP logs for stream: ${streamId}`);
+    const { resourceLogs } = body;
+    if (!resourceLogs || !Array.isArray(resourceLogs)) {
+        throw new Error("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++;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    console.log(`[API] /v1/logs Ingested ${count} logs`);
+    return { partialSuccess: {}, logsIngested: count };
+}

package/dist/api/server.js

@@ -4,6 +4,7 @@ import path from "path";
 import fs from "fs";
 import { fileURLToPath } from "url";
 import chalk from "chalk";
+import { ingestCustomLogs, ingestOtlpLogs } from "./controllers.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 export async function startApiServer(db, auth) {
@@ -26,35 +27,6 @@ export async function startApiServer(db, auth) {
         console.warn(chalk.yellow("Frontend build not found. Run 'npm run build' in packages/core/frontend to build the UI."));
     }
     await auth.initialize();
-    // console.log(chalk.bold.green(`\n💻 API server running on:`));
-    // console.log(chalk.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;
-    };
     app.post("/v1/logs", async (req, res) => {
         console.log(`[API] POST /v1/logs received`);
         try {
@@ -64,60 +36,17 @@ export async function startApiServer(db, auth) {
                 return res.status(401).json({ code: 16, message: "Unauthenticated" });
             }
             const token = authHeader.split(" ")[1];
-            const payload = await auth.verifyToken(token);
-            if (!payload || !payload.streamId) {
-                console.warn("[API] /v1/logs Unauthorized: Invalid token");
-                return res.status(401).json({ code: 16, message: "Invalid token" });
-            }
-            const streamId = payload.streamId;
-            console.log(`[API] Ingesting OTLP logs for stream: ${streamId}`);
-            const { resourceLogs } = req.body;
-            if (!resourceLogs || !Array.isArray(resourceLogs)) {
-                console.warn("[API] /v1/logs Invalid payload");
-                return res.status(400).json({ code: 3, message: "Invalid payload" });
-            }
-            // ... existing logic ...
-            let count = 0;
-            // ... loop ...
-            // (I will keep the existing loop logic but add a log at the end)
-            /* ... existing loop code ... */
-            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++;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            console.log(`[API] /v1/logs Ingested ${count} logs`);
-            res.json({ partialSuccess: {}, logsIngested: count });
+            const result = await ingestOtlpLogs(req.body, token, db, auth);
+            res.json(result);
         }
         catch (e) {
             console.error("OTLP Ingest error:", e);
+            if (e.message.includes("Unauthorized")) {
+                return res.status(401).json({ code: 16, message: e.message });
+            }
+            if (e.message.includes("Invalid payload")) {
+                return res.status(400).json({ code: 3, message: e.message });
+            }
             res.status(500).json({ code: 13, message: String(e) });
         }
     });
@@ -130,42 +59,20 @@ export async function startApiServer(db, auth) {
                 return res.status(401).send("Unauthorized: Missing token");
             }
             const token = authHeader.split(" ")[1];
-            const payload = await auth.verifyToken(token);
-            if (!payload || !payload.streamId) {
-                console.warn("[API] /api/ingest Unauthorized: Invalid token");
-                return res.status(401).send("Unauthorized: Invalid token");
-            }
-            const { streamId, logs } = req.body;
-            console.log(`[API] Ingesting logs for stream: ${streamId}`);
-            if (streamId !== payload.streamId) {
-                console.warn(`[API] /api/ingest Forbidden: Token streamId ${payload.streamId} != body streamId ${streamId}`);
-                return res.status(403).send("Forbidden: Token does not match streamId");
-            }
-            if (!logs) {
-                console.warn("[API] /api/ingest Missing logs");
-                return res.status(400).send("Missing logs");
-            }
-            const logEntries = Array.isArray(logs) ? logs : [logs];
-            console.log(`[API] Processing ${logEntries.length} log entries`);
-            for (const log of logEntries) {
-                let content = "";
-                let metadata = {};
-                if (typeof log === "string") {
-                    content = log;
-                }
-                else if (typeof log === "object") {
-                    content = log.content || JSON.stringify(log);
-                    metadata = log.metadata || {};
-                }
-                if (content) {
-                    await db.addLog(streamId, content, metadata);
-                }
-            }
-            console.log(`[API] /api/ingest Successfully added ${logEntries.length} logs`);
-            res.json({ success: true, count: logEntries.length });
+            const result = await ingestCustomLogs(req.body, token, db, auth);
+            res.json(result);
         }
         catch (e) {
             console.error("Ingest error:", e);
+            if (e.message.includes("Unauthorized")) {
+                return res.status(401).send(e.message);
+            }
+            if (e.message.includes("Forbidden")) {
+                return res.status(403).send(e.message);
+            }
+            if (e.message.includes("Missing logs")) {
+                return res.status(400).send(e.message);
+            }
             res.status(500).json({ error: String(e) });
         }
     });
@@ -207,6 +114,15 @@ export async function startApiServer(db, auth) {
         await db.deleteProject(id);
         res.json({ success: true });
     });
+    app.patch("/api/projects/:id", async (req, res) => {
+        const { id } = req.params;
+        const { name } = req.body;
+        if (!name || !name.trim()) {
+            return res.status(400).send("Name required");
+        }
+        const project = await db.renameProject(id, name.trim());
+        res.json(project);
+    });
     app.get("/api/streams", async (req, res) => {
         const projectId = req.query.projectId;
         if (projectId) {
@@ -222,6 +138,15 @@ export async function startApiServer(db, auth) {
         await db.deleteStream(id);
         res.json({ success: true });
     });
+    app.patch("/api/streams/:id", async (req, res) => {
+        const { id } = req.params;
+        const { name } = req.body;
+        if (!name || !name.trim()) {
+            return res.status(400).send("Name required");
+        }
+        const stream = await db.renameStream(id, name.trim());
+        res.json(stream);
+    });
     app.get("/api/streams/:id/token", async (req, res) => {
         const { id } = req.params;
         try {
@@ -300,6 +225,50 @@ export async function startApiServer(db, auth) {
         }
         res.json(logs);
     });
+    app.get("/api/issues", async (req, res) => {
+        const projectId = req.query.projectId;
+        const status = req.query.status;
+        const limit = parseInt(req.query.limit || "50");
+        if (!projectId) {
+            return res.status(400).send("Missing projectId");
+        }
+        try {
+            const issues = await db.getIssues(projectId, status, limit);
+            res.json(issues);
+        }
+        catch (e) {
+            console.error("Error fetching issues:", e);
+            res.status(500).send(String(e));
+        }
+    });
+    app.get("/api/issues/:id", async (req, res) => {
+        const { id } = req.params;
+        try {
+            const data = await db.getIssue(id);
+            if (!data)
+                return res.status(404).send("Issue not found");
+            res.json(data);
+        }
+        catch (e) {
+            console.error("Error fetching issue details:", e);
+            res.status(500).send(String(e));
+        }
+    });
+    app.patch("/api/issues/:id", async (req, res) => {
+        const { id } = req.params;
+        const { status } = req.body;
+        if (status !== "open" && status !== "resolved") {
+            return res.status(400).send("Invalid status");
+        }
+        try {
+            await db.updateIssueStatus(id, status);
+            res.json({ success: true });
+        }
+        catch (e) {
+            console.error("Error updating issue:", e);
+            res.status(500).send(String(e));
+        }
+    });
     // SPA fallback
     app.get("*", (req, res) => {
         if (req.path.startsWith("/api")) {