@junando/webhook 0.7.4 → 0.8.0

package/dist/handler.cjs

@@ -4468,62 +4468,6 @@ var init_normalize_payload = __esm({
   }
 });
 
-// ../core/src/application/use-cases/process-incident.use-case.ts
-var ProcessIncidentUseCase;
-var init_process_incident_use_case = __esm({
-  "../core/src/application/use-cases/process-incident.use-case.ts"() {
-    init_clustering_service();
-    ProcessIncidentUseCase = class {
-      constructor(deps) {
-        this.deps = deps;
-        this.clustering = deps.clustering ?? new ClusteringService();
-      }
-      deps;
-      clustering;
-      async execute(alerts, correlationId) {
-        const { dedup, traces, llm, notifier, logger: logger8, dedupTtlSeconds } = this.deps;
-        const log = logger8.child({ correlationId, useCase: "ProcessIncident" });
-        log.info({ alertCount: alerts.length }, "Processing alert batch");
-        const clusters = this.clustering.buildClusters(alerts);
-        log.info({ clusterCount: clusters.length }, "Clusters built");
-        this.deps.onClustersBuilt?.(clusters.length);
-        for (const cluster of clusters) {
-          const log2 = log.child({ fingerprint: cluster.fingerprint, service: cluster.serviceName });
-          const isNew = await dedup.isNew(cluster.fingerprint, dedupTtlSeconds);
-          if (!isNew) {
-            log2.debug("Duplicate cluster \u2014 skipping");
-            continue;
-          }
-          const spanLists = await Promise.all(
-            cluster.representativeTraceIds.map(
-              (id) => traces.findByTraceId(id).catch((err) => {
-                log2.warn({ err, traceId: id }, "Trace fetch failed \u2014 continuing without it");
-                return [];
-              })
-            )
-          );
-          const allSpans = spanLists.flat();
-          log2.info({ spanCount: allSpans.length }, "Traces extracted");
-          let analysis = null;
-          try {
-            analysis = await llm.analyze(cluster, allSpans);
-            log2.info({ urgency: analysis.urgency_level }, "LLM analysis complete");
-          } catch (err) {
-            log2.warn({ err }, "LLM inference failed \u2014 notifying without diagnosis");
-          }
-          try {
-            await notifier.send(cluster, analysis);
-            log2.info("Notification sent");
-          } catch (err) {
-            log2.error({ err }, "Notification failed");
-            throw err;
-          }
-        }
-      }
-    };
-  }
-});
-
 // ../../node_modules/.pnpm/prom-client@15.1.3/node_modules/prom-client/lib/util.js
 var require_util = __commonJS({
   "../../node_modules/.pnpm/prom-client@15.1.3/node_modules/prom-client/lib/util.js"(exports2) {
@@ -9237,15 +9181,19 @@ __export(metrics_exports, {
   alertClusters: () => alertClusters,
   alertsProcessed: () => alertsProcessed,
   alertsReceived: () => alertsReceived,
+  dedupDuplicate: () => dedupDuplicate,
+  dedupNew: () => dedupNew,
   dedupRedisFailoverTotal: () => dedupRedisFailoverTotal,
   latency: () => latency,
   llmInferenceDuration: () => llmInferenceDuration,
   llmInferenceTotal: () => llmInferenceTotal,
+  notificationsTotal: () => notificationsTotal,
   pipelineInlineFailuresTotal: () => pipelineInlineFailuresTotal,
   registry: () => registry,
+  sqsQueueLag: () => sqsQueueLag,
   webhookRequestsTotal: () => webhookRequestsTotal
 });
-var import_prom_client, registry, alertsReceived, webhookRequestsTotal, alertsProcessed, alertClusters, latency, llmInferenceDuration, llmInferenceTotal, pipelineInlineFailuresTotal, dedupRedisFailoverTotal;
+var import_prom_client, registry, alertsReceived, webhookRequestsTotal, alertsProcessed, alertClusters, latency, llmInferenceDuration, llmInferenceTotal, pipelineInlineFailuresTotal, dedupRedisFailoverTotal, dedupNew, dedupDuplicate, notificationsTotal, sqsQueueLag;
 var init_metrics2 = __esm({
   "../core/src/shared/metrics/index.ts"() {
     import_prom_client = __toESM(require_prom_client());
@@ -9265,6 +9213,7 @@ var init_metrics2 = __esm({
     alertsProcessed = new import_prom_client.Counter({
       name: "junando_alerts_processed_total",
       help: "Total number of alerts processed successfully",
+      labelNames: ["result"],
       registers: [registry]
     });
     alertClusters = new import_prom_client.Gauge({
@@ -9275,7 +9224,8 @@ var init_metrics2 = __esm({
     latency = new import_prom_client.Histogram({
       name: "junando_webhook_duration_seconds",
       help: "Webhook request duration in seconds",
-      buckets: [0.01, 0.05, 0.1, 0.25, 0.5, 1],
+      labelNames: ["status"],
+      buckets: [5e-3, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5],
       registers: [registry]
     });
     llmInferenceDuration = new import_prom_client.Histogram({
@@ -9302,6 +9252,89 @@ var init_metrics2 = __esm({
       help: "Total number of Redis dedup fallback activations",
       registers: [registry]
     });
+    dedupNew = new import_prom_client.Counter({
+      name: "junando_dedup_new_total",
+      help: "Total number of new alert clusters (not yet seen)",
+      labelNames: ["source"],
+      registers: [registry]
+    });
+    dedupDuplicate = new import_prom_client.Counter({
+      name: "junando_dedup_duplicate_total",
+      help: "Total number of duplicate alert clusters skipped by dedup",
+      labelNames: ["source"],
+      registers: [registry]
+    });
+    notificationsTotal = new import_prom_client.Counter({
+      name: "junando_notifications_total",
+      help: "Total number of notification attempts",
+      labelNames: ["channel", "outcome"],
+      registers: [registry]
+    });
+    sqsQueueLag = new import_prom_client.Gauge({
+      name: "junando_sqs_queue_lag",
+      help: "Approximate number of unprocessed messages in the SQS queue",
+      labelNames: ["queue_name"],
+      registers: [registry]
+    });
+  }
+});
+
+// ../core/src/application/use-cases/process-incident.use-case.ts
+var ProcessIncidentUseCase;
+var init_process_incident_use_case = __esm({
+  "../core/src/application/use-cases/process-incident.use-case.ts"() {
+    init_clustering_service();
+    init_metrics2();
+    ProcessIncidentUseCase = class {
+      constructor(deps) {
+        this.deps = deps;
+        this.clustering = deps.clustering ?? new ClusteringService();
+      }
+      deps;
+      clustering;
+      async execute(alerts, correlationId) {
+        const { dedup, traces, llm, notifier, logger: logger8, dedupTtlSeconds } = this.deps;
+        const log = logger8.child({ correlationId, useCase: "ProcessIncident" });
+        log.info({ alertCount: alerts.length }, "Processing alert batch");
+        const clusters = this.clustering.buildClusters(alerts);
+        log.info({ clusterCount: clusters.length }, "Clusters built");
+        this.deps.onClustersBuilt?.(clusters.length);
+        for (const cluster of clusters) {
+          const log2 = log.child({ fingerprint: cluster.fingerprint, service: cluster.serviceName });
+          const isNew = await dedup.isNew(cluster.fingerprint, dedupTtlSeconds);
+          if (!isNew) {
+            log2.debug("Duplicate cluster \u2014 skipping");
+            dedupDuplicate.inc({ source: "alertmanager" });
+            continue;
+          }
+          dedupNew.inc({ source: "alertmanager" });
+          const spanLists = await Promise.all(
+            cluster.representativeTraceIds.map(
+              (id) => traces.findByTraceId(id).catch((err) => {
+                log2.warn({ err, traceId: id }, "Trace fetch failed \u2014 continuing without it");
+                return [];
+              })
+            )
+          );
+          const allSpans = spanLists.flat();
+          log2.info({ spanCount: allSpans.length }, "Traces extracted");
+          let analysis = null;
+          try {
+            analysis = await llm.analyze(cluster, allSpans);
+            log2.info({ urgency: analysis.urgency_level }, "LLM analysis complete");
+          } catch (err) {
+            log2.warn({ err }, "LLM inference failed \u2014 notifying without diagnosis");
+          }
+          try {
+            await notifier.send(cluster, analysis);
+            log2.info("Notification sent");
+          } catch (err) {
+            log2.error({ err }, "Notification failed");
+            throw err;
+          }
+        }
+      }
+    };
   }
 });
 
@@ -25820,6 +25853,7 @@ var init_slack_adapter = __esm({
   "../core/src/infrastructure/notifier/slack.adapter.ts"() {
     init_constants();
     init_logger();
+    init_metrics2();
     logger3 = createLogger();
     SlackNotifier = class {
       constructor(botToken, channel) {
@@ -25830,18 +25864,24 @@ var init_slack_adapter = __esm({
       channel;
       async send(cluster, analysis) {
         const payload = analysis ? this.buildAnalysisMessage(cluster, analysis) : this.buildFallbackMessage(cluster);
-        const res = await fetch(SLACK_API_URL, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${this.botToken}`
-          },
-          body: JSON.stringify({ channel: this.channel, ...payload }),
-          signal: AbortSignal.timeout(HTTP_TIMEOUT_MS.Default)
-        });
-        if (!res.ok) throw new Error(`Slack API error: ${res.status}`);
-        const body = await res.json();
-        if (!body.ok) throw new Error(`Slack error: ${body.error}`);
+        try {
+          const res = await fetch(SLACK_API_URL, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${this.botToken}`
+            },
+            body: JSON.stringify({ channel: this.channel, ...payload }),
+            signal: AbortSignal.timeout(HTTP_TIMEOUT_MS.Default)
+          });
+          if (!res.ok) throw new Error(`Slack API error: ${res.status}`);
+          const body = await res.json();
+          if (!body.ok) throw new Error(`Slack error: ${body.error}`);
+          notificationsTotal.inc({ channel: "slack", outcome: "success" });
+        } catch (err) {
+          notificationsTotal.inc({ channel: "slack", outcome: "failure" });
+          throw err;
+        }
       }
       buildAnalysisMessage(cluster, analysis) {
         const emoji = URGENCY_EMOJI[analysis.urgency_level] ?? "\u26AA";
@@ -25945,17 +25985,23 @@ LLM analysis unavailable \u2014 manual investigation required.`
     ConsoleNotifier = class {
       sent = [];
       async send(cluster, analysis) {
-        this.sent.push({ cluster, analysis });
-        logger3.info(
-          {
-            cluster: {
-              serviceName: cluster.serviceName,
-              alertType: cluster.alertType
+        try {
+          this.sent.push({ cluster, analysis });
+          logger3.info(
+            {
+              cluster: {
+                serviceName: cluster.serviceName,
+                alertType: cluster.alertType
+              },
+              analysis: analysis ?? "unavailable"
             },
-            analysis: analysis ?? "unavailable"
-          },
-          "--- Junando Notification ---"
-        );
+            "--- Junando Notification ---"
+          );
+          notificationsTotal.inc({ channel: "unknown", outcome: "success" });
+        } catch (err) {
+          notificationsTotal.inc({ channel: "unknown", outcome: "failure" });
+          throw err;
+        }
       }
     };
   }
@@ -26078,6 +26124,7 @@ var TeamsNotifierError, TeamsNotifier;
 var init_teams_adapter = __esm({
   "../core/src/infrastructure/notifier/teams.adapter.ts"() {
     init_constants();
+    init_metrics2();
     TeamsNotifierError = class extends Error {
       constructor(message) {
         super(message);
@@ -26118,15 +26165,20 @@ var init_teams_adapter = __esm({
               `Teams webhook error ${res.status} (host: ${this.hostForErrors})`
             );
           }
+          notificationsTotal.inc({ channel: "teams", outcome: "success" });
         } catch (err) {
           if (err instanceof TeamsNotifierError) {
+            notificationsTotal.inc({ channel: "teams", outcome: "failure" });
             throw err;
           }
           if (err instanceof Error && err.name === "AbortError") {
-            throw new TeamsNotifierError(
+            const timeoutErr = new TeamsNotifierError(
               `Teams webhook timed out after ${this.timeoutMs}ms (host: ${this.hostForErrors})`
             );
+            notificationsTotal.inc({ channel: "teams", outcome: "failure" });
+            throw timeoutErr;
           }
+          notificationsTotal.inc({ channel: "teams", outcome: "failure" });
           throw err;
         } finally {
           clearTimeout(timer);
@@ -53647,6 +53699,36 @@ var init_sqs_adapter = __esm({
   }
 });
 
+// ../core/src/infrastructure/queue/sqs-lag-poller.ts
+function startSqsLagPoller(queueUrl, intervalMs, region) {
+  const client = new SQSClient(region ? { region } : {});
+  const poll = async () => {
+    try {
+      const result = await client.send(
+        new GetQueueAttributesCommand({
+          QueueUrl: queueUrl,
+          AttributeNames: ["ApproximateNumberOfMessages"]
+        })
+      );
+      const raw = result.Attributes?.["ApproximateNumberOfMessages"];
+      if (raw !== void 0) {
+        sqsQueueLag.set({ queue_name: "alerts" }, parseInt(raw, 10));
+      }
+    } catch {
+    }
+  };
+  const timer = setInterval(() => {
+    void poll();
+  }, intervalMs);
+  return () => clearInterval(timer);
+}
+var init_sqs_lag_poller = __esm({
+  "../core/src/infrastructure/queue/sqs-lag-poller.ts"() {
+    init_dist_es61();
+    init_metrics2();
+  }
+});
+
 // ../core/src/infrastructure/traces/loki-trace.adapter.ts
 var LokiTraceRepository, MockTraceRepository;
 var init_loki_trace_adapter = __esm({
@@ -68746,7 +68828,8 @@ __export(src_exports, {
   loadConfig: () => loadConfig3,
   metrics: () => metrics_exports,
   normalizePayload: () => normalizePayload,
-  reinitLogger: () => reinitLogger
+  reinitLogger: () => reinitLogger,
+  startSqsLagPoller: () => startSqsLagPoller
 });
 var init_src3 = __esm({
   "../core/src/index.ts"() {
@@ -68764,6 +68847,7 @@ var init_src3 = __esm({
     init_slack_adapter();
     init_teams_adapter();
     init_sqs_adapter();
+    init_sqs_lag_poller();
     init_loki_trace_adapter();
     init_config7();
     init_constants();
@@ -68826,6 +68910,7 @@ var handler = async (event) => {
 };
 async function _handler(event) {
   const QUEUE_URL = process.env["SQS_QUEUE_URL"] ?? "";
+  const start = Date.now();
   const correlationId = crypto2.randomUUID();
   if (event.rawPath === "/health") {
     metrics_exports.webhookRequestsTotal.inc({ endpoint: "/health", status: "200" });
@@ -68901,6 +68986,7 @@ async function _handler(event) {
   const parsed = AlertmanagerPayloadSchema.safeParse(raw);
   if (!parsed.success) {
     metrics_exports.webhookRequestsTotal.inc({ endpoint: "/webhook/alert", status: "422" });
+    metrics_exports.latency.observe({ status: "error" }, (Date.now() - start) / 1e3);
     return {
       statusCode: 422,
       body: JSON.stringify({
@@ -68981,6 +69067,7 @@ async function _handler(event) {
       logger7.error({ err, correlationId }, "Failed to initialize inline pipeline");
     }
   }
+  metrics_exports.latency.observe({ status: "success" }, (Date.now() - start) / 1e3);
   return {
     statusCode: 200,
     body: JSON.stringify({ accepted: alerts.length, correlationId })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junando/webhook",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "description": "AWS Lambda webhook handler — receives and enqueues external alert payloads for Junando",
   "license": "Apache-2.0",
   "type": "module",
@@ -20,7 +20,7 @@
   "dependencies": {
     "@aws-sdk/client-sqs": "^3.600.0",
     "zod": "^3.23.0",
-    "@junando/core": "0.7.4"
+    "@junando/core": "0.8.0"
   },
   "devDependencies": {
     "@types/aws-lambda": "^8.10.145",