@meyicloud/meyi-cost-server 1.7.1 → 1.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meyicloud/meyi-cost-server",
-  "version": "1.7.1",
+  "version": "1.8.1",
   "description": "Tenant-aware AWS CUR and Athena cost plugin server for MeyiConnect",
   "type": "module",
   "main": "./index.js",

package/src/plugin.js

@@ -17,6 +17,7 @@ import { CostAnalyserService } from "./services/cost-analyser.service.js";
 import { CostAnalysisReportService } from "./services/cost-analysis-report.service.js";
 import { CostReportArtifactService } from "./services/cost-report-artifact.service.js";
 import { CostAnalysisReportWorker } from "./workers/cost-analysis-report.worker.js";
+import { CostIncidentSyncService } from "./services/cost-incident-sync.service.js";
 import { installCurDiscoverySchema } from "./cur-discovery/schema.js";
 import { CurDiscoveryRepository } from "./cur-discovery/cur-discovery.repository.js";
 import { CurDiscoveryAws } from "./cur-discovery/cur-discovery.aws.js";
@@ -24,7 +25,7 @@ import { CurDiscoveryService } from "./cur-discovery/cur-discovery.service.js";
 import { CurDiscoveryWorker } from "./cur-discovery/cur-discovery.worker.js";
 import { safeSchema } from "./lib/cost-utils.js";
 
-export function createInsightCost({ app, db, apiBaseUri = "/api/v1", logger = console, providerResolver = null } = {}) {
+export function createInsightCost({ app, db, apiBaseUri = "/api/v1", logger = console, providerResolver = null, incidentSink = null } = {}) {
   if (!db) throw new Error("db is required");
   const schema = safeSchema(process.env.DB_SCHEMA || "meyiconnect");
   const qSchema = `"${schema}"`;
@@ -53,8 +54,9 @@ export function createInsightCost({ app, db, apiBaseUri = "/api/v1", logger = co
   const budgetController = new BudgetController({ contextService, budgetService, budgetAlertService });
   const costAnalyserService = new CostAnalyserService({ contextService, athenaContextService, providerResolver, logger });
   const artifactService = new CostReportArtifactService();
+  const incidentSyncService = new CostIncidentSyncService({ repository: costAnalysisReportRepository, artifactService, incidentSink, logger });
   const costAnalysisReportService = new CostAnalysisReportService({ contextService, repository: costAnalysisReportRepository, artifactService });
-  const costAnalysisReportWorker = new CostAnalysisReportWorker({ repository: costAnalysisReportRepository, analyserService: costAnalyserService, logger });
+  const costAnalysisReportWorker = new CostAnalysisReportWorker({ repository: costAnalysisReportRepository, analyserService: costAnalyserService, incidentSyncService, logger });
   const costAnalysisController = new CostAnalysisController({ service: costAnalyserService, reportService: costAnalysisReportService });
   const router = createCostRouter({ costController, budgetController, costAnalysisController }, logger);
   let mounted = false;

package/src/repositories/cost-analysis-report.repository.js

@@ -89,11 +89,35 @@ export class CostAnalysisReportRepository {
         result = ${JSON.stringify(result.summary || {})}::jsonb, artifact_bucket = ${result.artifactBucket},
         markdown_key = ${result.markdownKey}, markdown_size = ${Number(result.markdownSize || 0)},
         pdf_key = ${result.pdfKey}, pdf_size = ${Number(result.pdfSize || 0)}, pdf_data = NULL,
+        tickets_key = ${result.ticketsKey || null}, ticket_count = ${Number(result.ticketCount || 0)},
+        incident_sync_status = ${Number(result.ticketCount || 0) > 0 ? "PENDING" : "COMPLETED"},
+        incident_sync_error = NULL,
+        incident_synced_at = ${Number(result.ticketCount || 0) > 0 ? null : new Date()},
         completed_at = now(), updated_at = now()
       WHERE id = ${id}
     `);
   }
 
+  async findIncidentSyncCandidates(limit = 10) {
+    return rows(await this.db.execute(sql`
+      SELECT * FROM ${sql.raw(this.reports)}
+      WHERE status = 'COMPLETED'
+        AND COALESCE(ticket_count, (result->>'ticketCount')::integer, 0) > 0
+        AND incident_sync_status IN ('PENDING', 'FAILED')
+      ORDER BY completed_at ASC
+      LIMIT ${Math.min(Math.max(Number(limit) || 10, 1), 50)}
+    `));
+  }
+
+  async setIncidentSyncState(reportId, status, error = null) {
+    await this.db.execute(sql`
+      UPDATE ${sql.raw(this.reports)}
+      SET incident_sync_status = ${status}, incident_sync_error = ${error ? String(error?.message || error).slice(0, 2000) : null},
+          incident_synced_at = ${status === "COMPLETED" ? new Date() : null}, updated_at = now()
+      WHERE id = ${reportId}
+    `);
+  }
+
   async complete(id, analysis, pdf) {
     await this.db.execute(sql`
       UPDATE ${sql.raw(this.reports)} SET status = 'COMPLETED', model_id = ${analysis.modelId}, data_source = ${analysis.dataSource || null},
@@ -112,7 +136,8 @@ export class CostAnalysisReportRepository {
     return rows(await this.db.execute(sql`
       SELECT id, schedule_frequency, scheduled_for, period_start, period_end, status,
              attempt_count, model_id, provider_name, provider_source, data_source, facts, result, artifact_bucket,
-             markdown_key, markdown_size, pdf_key, pdf_size, error,
+             markdown_key, markdown_size, pdf_key, pdf_size, tickets_key, ticket_count,
+             incident_sync_status, incident_sync_error, incident_synced_at, error,
              started_at, completed_at, created_at
       FROM ${sql.raw(this.reports)} WHERE tenant_id = ${tenantId}
       ORDER BY scheduled_for DESC LIMIT ${Math.min(Math.max(Number(limit) || 100, 1), 250)}
@@ -126,7 +151,8 @@ export class CostAnalysisReportRepository {
     return rows(await this.db.execute(sql`
       SELECT id, schedule_frequency, scheduled_for, period_start, period_end, status,
              attempt_count, model_id, provider_name, provider_source, data_source, facts, result, artifact_bucket,
-             markdown_key, markdown_size, pdf_key, pdf_size, error,
+             markdown_key, markdown_size, pdf_key, pdf_size, tickets_key, ticket_count,
+             incident_sync_status, incident_sync_error, incident_synced_at, error,
              started_at, completed_at, created_at
       FROM ${sql.raw(this.reports)} WHERE tenant_id = ${tenantId} AND id = ${id} LIMIT 1
     `))[0] || null;

package/src/schema/cost-analysis-report.schema.js

@@ -38,6 +38,11 @@ export async function installCostAnalysisReportSchema(db, qSchema) {
     markdown_key text,
     markdown_size integer,
     pdf_key text,
+    tickets_key text,
+    ticket_count integer NOT NULL DEFAULT 0,
+    incident_sync_status text NOT NULL DEFAULT 'PENDING' CHECK (incident_sync_status IN ('PENDING', 'COMPLETED', 'FAILED')),
+    incident_sync_error text,
+    incident_synced_at timestamptz,
     error text,
     started_at timestamptz,
     completed_at timestamptz,
@@ -54,4 +59,13 @@ export async function installCostAnalysisReportSchema(db, qSchema) {
   await db.execute(sql.raw(`ALTER TABLE ${qSchema}.cost_ai_reports ADD COLUMN IF NOT EXISTS pdf_key text`));
   await db.execute(sql.raw(`ALTER TABLE ${qSchema}.cost_ai_reports ADD COLUMN IF NOT EXISTS provider_name text`));
   await db.execute(sql.raw(`ALTER TABLE ${qSchema}.cost_ai_reports ADD COLUMN IF NOT EXISTS provider_source text`));
+  await db.execute(sql.raw(`ALTER TABLE ${qSchema}.cost_ai_reports ADD COLUMN IF NOT EXISTS tickets_key text`));
+  await db.execute(sql.raw(`ALTER TABLE ${qSchema}.cost_ai_reports ADD COLUMN IF NOT EXISTS ticket_count integer NOT NULL DEFAULT 0`));
+  await db.execute(sql.raw(`ALTER TABLE ${qSchema}.cost_ai_reports ADD COLUMN IF NOT EXISTS incident_sync_status text NOT NULL DEFAULT 'PENDING'`));
+  await db.execute(sql.raw(`ALTER TABLE ${qSchema}.cost_ai_reports ADD COLUMN IF NOT EXISTS incident_sync_error text`));
+  await db.execute(sql.raw(`ALTER TABLE ${qSchema}.cost_ai_reports ADD COLUMN IF NOT EXISTS incident_synced_at timestamptz`));
+  await db.execute(sql.raw(`UPDATE ${qSchema}.cost_ai_reports
+    SET ticket_count = (result->>'ticketCount')::integer
+    WHERE ticket_count = 0 AND result ? 'ticketCount' AND (result->>'ticketCount') ~ '^[0-9]+$'`));
+  await db.execute(sql.raw(`DROP TABLE IF EXISTS ${qSchema}.cost_ai_incident_tickets`));
 }

package/src/services/cost-incident-sync.service.js

@@ -0,0 +1,50 @@
+export class CostIncidentSyncService {
+  constructor({ repository, artifactService, incidentSink = null, logger = console }) {
+    this.repository = repository;
+    this.artifactService = artifactService;
+    this.incidentSink = incidentSink;
+    this.logger = logger;
+  }
+
+  ticketsKey(report) {
+    if (report.tickets_key) return report.tickets_key;
+    const artifactKey = report.markdown_key || report.pdf_key || "";
+    const slash = artifactKey.lastIndexOf("/");
+    return slash >= 0 ? `${artifactKey.slice(0, slash + 1)}tickets.json` : null;
+  }
+
+  async syncReport(report) {
+    if (!this.incidentSink) return false;
+    try {
+      const key = this.ticketsKey(report);
+      if (!report.artifact_bucket || !key) throw new Error("FinOps ticket artifact location is missing");
+      const data = await this.artifactService.get(report.artifact_bucket, key);
+      if (!data) throw new Error("FinOps ticket artifact is empty");
+      const parsed = JSON.parse(data.toString("utf8"));
+      const tickets = Array.isArray(parsed?.tickets) ? parsed.tickets.filter((ticket) => ticket?.ticket_id) : [];
+
+      for (const ticket of tickets) {
+        const result = await this.incidentSink({ tenantId: report.tenant_id, report, ticket });
+        if (!result?.id) throw new Error(`Incident integration did not return an incident ID for ${ticket.ticket_id}`);
+      }
+
+      await this.repository.setIncidentSyncState(report.id, "COMPLETED");
+      return true;
+    } catch (error) {
+      await this.repository.setIncidentSyncState(report.id, "FAILED", error);
+      this.logger.error?.("[Cost AI Reports] Incident synchronization failed", {
+        tenantId: report.tenant_id,
+        reportId: report.id,
+        message: error.message,
+      });
+      return false;
+    }
+  }
+
+  async syncPending(limit = 10) {
+    if (!this.incidentSink) return;
+    for (const report of await this.repository.findIncidentSyncCandidates(limit)) {
+      await this.syncReport(report);
+    }
+  }
+}

package/src/workers/cost-analysis-report.worker.js

@@ -1,8 +1,9 @@
 import { nextScheduleRun, reportRange } from "../lib/cost-analysis-schedule.js";
 export class CostAnalysisReportWorker {
-  constructor({ repository, analyserService, logger = console, env = process.env }) {
+  constructor({ repository, analyserService, incidentSyncService = null, logger = console, env = process.env }) {
     this.repository = repository;
     this.analyserService = analyserService;
+    this.incidentSyncService = incidentSyncService;
     this.logger = logger;
     this.enabled = String(env.COST_AI_ENABLED || "").toLowerCase() === "true";
     this.pollMs = Math.max(Number(env.COST_AI_REPORT_POLL_INTERVAL_MS || 60_000), 10_000);
@@ -30,6 +31,7 @@ export class CostAnalysisReportWorker {
         onStarted: (metadata) => this.repository.setTaskStarted(report.id, metadata),
       });
       await this.repository.completeExternal(report.id, result);
+      await this.incidentSyncService?.syncPending?.();
       await this.repository.setNextRun(schedule.tenant_id, nextRunAt, true, schedule.next_run_at);
     } catch (error) {
       await this.repository.fail(report.id, error);
@@ -42,6 +44,7 @@ export class CostAnalysisReportWorker {
     if (!this.enabled || this.running) return;
     this.running = true;
     try {
+      await this.incidentSyncService?.syncPending?.();
       const schedules = await this.repository.claimDue(this.batchSize, this.leaseMs);
       for (const schedule of schedules) await this.run(schedule);
     } catch (error) {