@junando/core 0.7.4 → 0.8.2

package/dist/index.d.ts

@@ -668,6 +668,8 @@ declare class InMemoryAlertQueue implements IAlertQueue {
     publish(alert: NormalizedAlert): Promise<void>;
 }
 
+declare function startSqsLagPoller(queueUrl: string, intervalMs: number, region?: string): () => void;
+
 declare class LokiTraceRepository implements ITraceRepository {
     private readonly lokiUrl;
     private readonly apiKey?;
@@ -693,28 +695,40 @@ declare function flushLoki(): Promise<void>;
 declare const registry: Registry<"text/plain; version=0.0.4; charset=utf-8">;
 declare const alertsReceived: Counter<"status">;
 declare const webhookRequestsTotal: Counter<"status" | "endpoint">;
-declare const alertsProcessed: Counter<string>;
+declare const alertsProcessed: Counter<"result">;
 declare const alertClusters: Gauge<string>;
-declare const latency: Histogram<string>;
+declare const latency: Histogram<"status">;
 declare const llmInferenceDuration: Histogram<"model">;
 declare const llmInferenceTotal: Counter<"status">;
 /** Tracks inline pipeline failures in local dev mode. */
 declare const pipelineInlineFailuresTotal: Counter<"reason">;
 /** Tracks Redis dedup fallback activations. */
 declare const dedupRedisFailoverTotal: Counter<string>;
+/** Tracks new alert clusters (dedup: first-time fingerprint). */
+declare const dedupNew: Counter<"source">;
+/** Tracks duplicate alert clusters (dedup: fingerprint already seen). */
+declare const dedupDuplicate: Counter<"source">;
+/** Tracks outbound notification attempts by channel and outcome. */
+declare const notificationsTotal: Counter<"channel" | "outcome">;
+/** Tracks approximate number of unprocessed SQS messages (queue lag). */
+declare const sqsQueueLag: Gauge<"queue_name">;
 
 declare const index_alertClusters: typeof alertClusters;
 declare const index_alertsProcessed: typeof alertsProcessed;
 declare const index_alertsReceived: typeof alertsReceived;
+declare const index_dedupDuplicate: typeof dedupDuplicate;
+declare const index_dedupNew: typeof dedupNew;
 declare const index_dedupRedisFailoverTotal: typeof dedupRedisFailoverTotal;
 declare const index_latency: typeof latency;
 declare const index_llmInferenceDuration: typeof llmInferenceDuration;
 declare const index_llmInferenceTotal: typeof llmInferenceTotal;
+declare const index_notificationsTotal: typeof notificationsTotal;
 declare const index_pipelineInlineFailuresTotal: typeof pipelineInlineFailuresTotal;
 declare const index_registry: typeof registry;
+declare const index_sqsQueueLag: typeof sqsQueueLag;
 declare const index_webhookRequestsTotal: typeof webhookRequestsTotal;
 declare namespace index {
-  export { index_alertClusters as alertClusters, index_alertsProcessed as alertsProcessed, index_alertsReceived as alertsReceived, index_dedupRedisFailoverTotal as dedupRedisFailoverTotal, index_latency as latency, index_llmInferenceDuration as llmInferenceDuration, index_llmInferenceTotal as llmInferenceTotal, index_pipelineInlineFailuresTotal as pipelineInlineFailuresTotal, index_registry as registry, index_webhookRequestsTotal as webhookRequestsTotal };
+  export { index_alertClusters as alertClusters, index_alertsProcessed as alertsProcessed, index_alertsReceived as alertsReceived, index_dedupDuplicate as dedupDuplicate, index_dedupNew as dedupNew, index_dedupRedisFailoverTotal as dedupRedisFailoverTotal, index_latency as latency, index_llmInferenceDuration as llmInferenceDuration, index_llmInferenceTotal as llmInferenceTotal, index_notificationsTotal as notificationsTotal, index_pipelineInlineFailuresTotal as pipelineInlineFailuresTotal, index_registry as registry, index_sqsQueueLag as sqsQueueLag, index_webhookRequestsTotal as webhookRequestsTotal };
 }
 
-export { ALERT_TYPE_LABELS, type AlertCluster, AlertClusterSchema, type AlertErrorType, type AlertStatus, AlertStatusSchema, AlertType, type AlertmanagerPayload, AlertmanagerPayloadSchema, CIRCUIT_BREAKER, ClaudeProvider, ClusteringService, type Config, ConsoleNotifier, DEDUP_TTL_MS_MULTIPLIER, DEV_SERVER_PORT, Fingerprint, GeminiProvider, HOUR_MS, HTTP_TIMEOUT_MS, type IAlertQueue, type IDeduplicationStore, type IIndexer, type ILLMProvider, type INotifier, type ITraceRepository, InMemoryAlertQueue, InMemoryDeduplicationStore, InMemoryIndexer, type Incident, IncidentSchema, type LLMAnalysis, LLMAnalysisSchema, LLMProviderType, LLM_FALLBACK_DEFAULTS, LLM_MAX_TOKENS, LLM_MODELS, type Logger, type LoggerOptions, LokiTraceRepository, MockLLMProvider, MockTraceRepository, type NormalizedAlert, NormalizedAlertSchema, type OpenSearchHttpFetcher, type OpenSearchHttpResponse, OpenSearchIndexer, type OpenSearchIndexerDeps, PAYLOAD_DEFAULTS, ProcessIncidentUseCase, RATE_LIMITER, REDIS_KEY_PREFIX, RedisDeduplicationStore, SLACK_API_URL, SQSAlertQueue, type SignedHttpRequest, SlackNotifier, TEAMS_WEBHOOK_TIMEOUT_MS, TeamsNotifier, TeamsNotifierError, type TraceabilityDocument, URGENCY_EMOJI, type UrgencyLevel, UrgencyLevelSchema, WEBHOOK_DEFAULTS, createLLMProvider, createLogger, createNotifier, flushLoki, loadConfig, index as metrics, normalizePayload, reinitLogger };
+export { ALERT_TYPE_LABELS, type AlertCluster, AlertClusterSchema, type AlertErrorType, type AlertStatus, AlertStatusSchema, AlertType, type AlertmanagerPayload, AlertmanagerPayloadSchema, CIRCUIT_BREAKER, ClaudeProvider, ClusteringService, type Config, ConsoleNotifier, DEDUP_TTL_MS_MULTIPLIER, DEV_SERVER_PORT, Fingerprint, GeminiProvider, HOUR_MS, HTTP_TIMEOUT_MS, type IAlertQueue, type IDeduplicationStore, type IIndexer, type ILLMProvider, type INotifier, type ITraceRepository, InMemoryAlertQueue, InMemoryDeduplicationStore, InMemoryIndexer, type Incident, IncidentSchema, type LLMAnalysis, LLMAnalysisSchema, LLMProviderType, LLM_FALLBACK_DEFAULTS, LLM_MAX_TOKENS, LLM_MODELS, type Logger, type LoggerOptions, LokiTraceRepository, MockLLMProvider, MockTraceRepository, type NormalizedAlert, NormalizedAlertSchema, type OpenSearchHttpFetcher, type OpenSearchHttpResponse, OpenSearchIndexer, type OpenSearchIndexerDeps, PAYLOAD_DEFAULTS, ProcessIncidentUseCase, RATE_LIMITER, REDIS_KEY_PREFIX, RedisDeduplicationStore, SLACK_API_URL, SQSAlertQueue, type SignedHttpRequest, SlackNotifier, TEAMS_WEBHOOK_TIMEOUT_MS, TeamsNotifier, TeamsNotifierError, type TraceabilityDocument, URGENCY_EMOJI, type UrgencyLevel, UrgencyLevelSchema, WEBHOOK_DEFAULTS, createLLMProvider, createLogger, createNotifier, flushLoki, loadConfig, index as metrics, normalizePayload, reinitLogger, startSqsLagPoller };

package/dist/index.js

@@ -367,68 +367,22 @@ function normalizePayload(payload) {
   );
 }
 
-// src/application/use-cases/process-incident.use-case.ts
-var 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: logger5, dedupTtlSeconds } = this.deps;
-    const log = logger5.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;
-      }
-    }
-  }
-};
-
 // src/shared/metrics/index.ts
 var metrics_exports = {};
 __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
 });
 import { Registry, Counter, Gauge, Histogram } from "prom-client";
@@ -448,6 +402,7 @@ var webhookRequestsTotal = new Counter({
 var alertsProcessed = new Counter({
   name: "junando_alerts_processed_total",
   help: "Total number of alerts processed successfully",
+  labelNames: ["result"],
   registers: [registry]
 });
 var alertClusters = new Gauge({
@@ -458,7 +413,8 @@ var alertClusters = new Gauge({
 var latency = new 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]
 });
 var llmInferenceDuration = new Histogram({
@@ -485,6 +441,82 @@ var dedupRedisFailoverTotal = new Counter({
   help: "Total number of Redis dedup fallback activations",
   registers: [registry]
 });
+var dedupNew = new Counter({
+  name: "junando_dedup_new_total",
+  help: "Total number of new alert clusters (not yet seen)",
+  labelNames: ["source"],
+  registers: [registry]
+});
+var dedupDuplicate = new Counter({
+  name: "junando_dedup_duplicate_total",
+  help: "Total number of duplicate alert clusters skipped by dedup",
+  labelNames: ["source"],
+  registers: [registry]
+});
+var notificationsTotal = new Counter({
+  name: "junando_notifications_total",
+  help: "Total number of notification attempts",
+  labelNames: ["channel", "outcome"],
+  registers: [registry]
+});
+var sqsQueueLag = new Gauge({
+  name: "junando_sqs_queue_lag",
+  help: "Approximate number of unprocessed messages in the SQS queue",
+  labelNames: ["queue_name"],
+  registers: [registry]
+});
+
+// src/application/use-cases/process-incident.use-case.ts
+var 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: logger5, dedupTtlSeconds } = this.deps;
+    const log = logger5.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;
+      }
+    }
+  }
+};
 
 // src/shared/logger/index.ts
 import pino from "pino";
@@ -988,18 +1020,24 @@ var SlackNotifier = class {
   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";
@@ -1103,17 +1141,23 @@ LLM analysis unavailable \u2014 manual investigation required.`
 var 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;
+    }
   }
 };
 
@@ -1270,15 +1314,20 @@ var TeamsNotifier = class {
           `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);
@@ -2305,6 +2354,7 @@ var _E = "Entries";
 var _EBR = "EmptyBatchRequest";
 var _F = "Failed";
 var _FR = "FailureReason";
+var _GQA = "GetQueueAttributes";
 var _GQAR = "GetQueueAttributesRequest";
 var _GQARe = "GetQueueAttributesResult";
 var _I = "Id";
@@ -3125,6 +3175,14 @@ var TagMap = [
     { [_xN]: _V }
   ]
 ];
+var GetQueueAttributes$ = [
+  9,
+  n0,
+  _GQA,
+  0,
+  () => GetQueueAttributesRequest$,
+  () => GetQueueAttributesResult$
+];
 var SendMessage$ = [
   9,
   n0,
@@ -3287,6 +3345,12 @@ var SQSClient = class extends Client {
   }
 };
 
+// ../../node_modules/.pnpm/@aws-sdk+client-sqs@3.1045.0/node_modules/@aws-sdk/client-sqs/dist-es/commands/GetQueueAttributesCommand.js
+var GetQueueAttributesCommand = class extends Command.classBuilder().ep(commonParams).m(function(Command2, cs, config, o) {
+  return [getEndpointPlugin(config, Command2.getEndpointParameterInstructions())];
+}).s("AmazonSQS", "GetQueueAttributes", {}).n("SQSClient", "GetQueueAttributesCommand").sc(GetQueueAttributes$).build() {
+};
+
 // ../../node_modules/.pnpm/@aws-sdk+client-sqs@3.1045.0/node_modules/@aws-sdk/client-sqs/dist-es/commands/SendMessageCommand.js
 var SendMessageCommand = class extends Command.classBuilder().ep(commonParams).m(function(Command2, cs, config, o) {
   return [
@@ -3347,6 +3411,30 @@ var InMemoryAlertQueue = class {
   }
 };
 
+// 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);
+}
+
 // src/infrastructure/traces/loki-trace.adapter.ts
 var LokiTraceRepository = class {
   constructor(lokiUrl, apiKey) {
@@ -9850,5 +9938,6 @@ export {
   loadConfig2 as loadConfig,
   metrics_exports as metrics,
   normalizePayload,
-  reinitLogger
+  reinitLogger,
+  startSqsLagPoller
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junando/core",
-  "version": "0.7.4",
+  "version": "0.8.2",
   "description": "Core domain types, interfaces, and shared utilities for the Junando alerting platform",
   "license": "Apache-2.0",
   "type": "module",