@meyicloud/meyi-cost-server 1.7.0 → 1.8.0

package/package.json

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

package/src/controllers/cost-analysis.controller.js

@@ -36,6 +36,11 @@ export class CostAnalysisController {
     catch (error) { return next(error); }
   }
 
+  async removeReport(req, res, next) {
+    try { return res.json(await this.reportService.remove(req, req.params.id)); }
+    catch (error) { return next(error); }
+  }
+
   async downloadPdf(req, res, next) {
     try {
       const report = await this.reportService.pdf(req, req.params.id);

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

@@ -7,6 +7,7 @@ export class CostAnalysisReportRepository {
     this.db = db;
     this.schedules = `${qSchema}.cost_ai_report_schedules`;
     this.reports = `${qSchema}.cost_ai_reports`;
+    this.incidentTickets = `${qSchema}.cost_ai_incident_tickets`;
   }
 
   async getSchedule(tenantId) {
@@ -71,8 +72,14 @@ export class CostAnalysisReportRepository {
     return rows(await this.db.execute(sql`UPDATE ${sql.raw(this.reports)} SET status = 'RUNNING', attempt_count = attempt_count + 1, started_at = now(), error = NULL, updated_at = now() WHERE id = ${id} AND status = 'PENDING' RETURNING *`))[0] || null;
   }
 
-  async setTaskArn(id, taskArn) {
-    await this.db.execute(sql`UPDATE ${sql.raw(this.reports)} SET ecs_task_arn = ${taskArn}, updated_at = now() WHERE id = ${id}`);
+  async setTaskStarted(id, { taskArn, provider, modelId, source, artifactBucket, markdownKey, pdfKey }) {
+    await this.db.execute(sql`
+      UPDATE ${sql.raw(this.reports)}
+      SET ecs_task_arn = ${taskArn}, provider_name = ${provider}, model_id = ${modelId},
+          provider_source = ${source}, artifact_bucket = ${artifactBucket},
+          markdown_key = ${markdownKey}, pdf_key = ${pdfKey}, updated_at = now()
+      WHERE id = ${id}
+    `);
   }
 
   async completeExternal(id, result) {
@@ -83,11 +90,72 @@ 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 stageIncidentTickets(report, tickets) {
+    for (const ticket of tickets) {
+      await this.db.execute(sql`
+        INSERT INTO ${sql.raw(this.incidentTickets)}
+          (tenant_id, ticket_id, report_id, payload)
+        VALUES (${report.tenant_id}, ${ticket.ticket_id}, ${report.id}, ${JSON.stringify(ticket)}::jsonb)
+        ON CONFLICT (tenant_id, ticket_id) DO UPDATE SET
+          payload = EXCLUDED.payload, report_id = EXCLUDED.report_id, updated_at = now()
+      `);
+    }
+  }
+
+  async listUnsyncedIncidentTickets(reportId) {
+    return rows(await this.db.execute(sql`
+      SELECT * FROM ${sql.raw(this.incidentTickets)}
+      WHERE report_id = ${reportId} AND sync_status IN ('PENDING', 'FAILED')
+      ORDER BY created_at ASC
+    `));
+  }
+
+  async markIncidentTicketSynced(tenantId, ticketId, incidentId) {
+    await this.db.execute(sql`
+      UPDATE ${sql.raw(this.incidentTickets)}
+      SET incident_id = ${incidentId}, sync_status = 'COMPLETED', sync_error = NULL,
+          synced_at = now(), updated_at = now()
+      WHERE tenant_id = ${tenantId} AND ticket_id = ${ticketId}
+    `);
+  }
+
+  async markIncidentTicketFailed(tenantId, ticketId, error) {
+    await this.db.execute(sql`
+      UPDATE ${sql.raw(this.incidentTickets)}
+      SET sync_status = 'FAILED', sync_error = ${String(error?.message || error).slice(0, 2000)}, updated_at = now()
+      WHERE tenant_id = ${tenantId} AND ticket_id = ${ticketId}
+    `);
+  }
+
+  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},
@@ -106,7 +174,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)}
@@ -120,9 +189,18 @@ 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;
   }
+
+  async remove(tenantId, id) {
+    return rows(await this.db.execute(sql`
+      DELETE FROM ${sql.raw(this.reports)}
+      WHERE tenant_id = ${tenantId} AND id = ${id}
+      RETURNING id
+    `))[0] || null;
+  }
 }

package/src/routes/index.js

@@ -15,6 +15,7 @@ export function createCostRouter({ costController, budgetController, costAnalysi
   router.put("/analysis/schedule", costAnalysisController.updateSchedule.bind(costAnalysisController));
   router.get("/analysis/reports", costAnalysisController.reports.bind(costAnalysisController));
   router.get("/analysis/reports/:id", costAnalysisController.report.bind(costAnalysisController));
+  router.delete("/analysis/reports/:id", costAnalysisController.removeReport.bind(costAnalysisController));
   router.get("/analysis/reports/:id/pdf", costAnalysisController.downloadPdf.bind(costAnalysisController));
   router.get("/analysis/reports/:id/markdown", costAnalysisController.downloadMarkdown.bind(costAnalysisController));
   router.get("/budgets", budgetController.list.bind(budgetController));

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,26 @@ 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(`CREATE TABLE IF NOT EXISTS ${qSchema}.cost_ai_incident_tickets (
+    tenant_id text NOT NULL,
+    ticket_id text NOT NULL,
+    report_id text NOT NULL REFERENCES ${qSchema}.cost_ai_reports(id) ON DELETE CASCADE,
+    payload jsonb NOT NULL,
+    incident_id text,
+    sync_status text NOT NULL DEFAULT 'PENDING' CHECK (sync_status IN ('PENDING', 'COMPLETED', 'FAILED')),
+    sync_error text,
+    synced_at timestamptz,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    updated_at timestamptz NOT NULL DEFAULT now(),
+    PRIMARY KEY (tenant_id, ticket_id)
+  )`));
+  await db.execute(sql.raw(`CREATE INDEX IF NOT EXISTS cost_ai_incident_tickets_report_idx ON ${qSchema}.cost_ai_incident_tickets (report_id, sync_status)`));
 }

package/src/services/cost-analyser.service.js

@@ -218,7 +218,13 @@ export class CostAnalyserService {
         throw Object.assign(new Error(`Unable to start cost analyser: ${reason}`), { name: "CostAnalyserLaunchError", statusCode: 502 });
       }
       const taskArn = launched.tasks[0].taskArn;
-      await onStarted?.(taskArn);
+      await onStarted?.({
+        taskArn,
+        ...this.statusSummary(provider),
+        artifactBucket: this.reportBucket,
+        markdownKey: `${prefix}/report.md`,
+        pdfKey: `${prefix}/report.pdf`,
+      });
       const deadline = Date.now() + this.timeoutMs;
       while (Date.now() < deadline) {
         const response = await this.ecs.send(new DescribeTasksCommand({ cluster: this.cluster, tasks: [taskArn] }));

package/src/services/cost-analysis-report.service.js

@@ -49,6 +49,25 @@ export class CostAnalysisReportService {
     return reportDto(row);
   }
 
+  async remove(req, id) {
+    if (String(req.user?.role || "").toLowerCase() !== "admin") {
+      throw Object.assign(new Error("Administrator access is required to remove AI report history"), { statusCode: 403 });
+    }
+    const tenantId = this.tenant(req);
+    const row = await this.repository.find(tenantId, id, true);
+    if (!row) throw Object.assign(new Error("AI cost report was not found"), { statusCode: 404 });
+    if (row.status === "PENDING" || row.status === "RUNNING") {
+      throw Object.assign(new Error("A running AI cost report cannot be removed"), { statusCode: 409 });
+    }
+    const artifactKey = row.markdown_key || row.pdf_key;
+    if (row.artifact_bucket && artifactKey) {
+      const slash = artifactKey.lastIndexOf("/");
+      await this.artifactService.removePrefix(row.artifact_bucket, slash >= 0 ? artifactKey.slice(0, slash + 1) : artifactKey);
+    }
+    await this.repository.remove(tenantId, id);
+    return { success: true };
+  }
+
   async pdf(req, id) {
     const row = await this.repository.find(this.tenant(req), id, true);
     if (!row) throw Object.assign(new Error("AI cost report was not found"), { statusCode: 404 });

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

@@ -0,0 +1,57 @@
+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) : [];
+      await this.repository.stageIncidentTickets(report, tickets);
+
+      for (const row of await this.repository.listUnsyncedIncidentTickets(report.id)) {
+        try {
+          const result = await this.incidentSink({ tenantId: report.tenant_id, report, ticket: row.payload });
+          if (!result?.id) throw new Error("Incident integration did not return an incident ID");
+          await this.repository.markIncidentTicketSynced(report.tenant_id, row.ticket_id, result.id);
+        } catch (error) {
+          await this.repository.markIncidentTicketFailed(report.tenant_id, row.ticket_id, error);
+          throw error;
+        }
+      }
+
+      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/services/cost-report-artifact.service.js

@@ -1,4 +1,4 @@
-import { GetObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { DeleteObjectsCommand, GetObjectCommand, ListObjectsV2Command, S3Client } from "@aws-sdk/client-s3";
 
 async function bytes(body) {
   if (!body) return Buffer.alloc(0);
@@ -18,5 +18,21 @@ export class CostReportArtifactService {
     const response = await this.client.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
     return bytes(response.Body);
   }
-}
 
+  async removePrefix(bucket, prefix) {
+    if (!bucket || !prefix) return;
+    let continuationToken;
+    do {
+      const page = await this.client.send(new ListObjectsV2Command({
+        Bucket: bucket,
+        Prefix: prefix,
+        ContinuationToken: continuationToken,
+      }));
+      const objects = (page.Contents || []).map(({ Key }) => ({ Key })).filter(({ Key }) => Boolean(Key));
+      if (objects.length) {
+        await this.client.send(new DeleteObjectsCommand({ Bucket: bucket, Delete: { Objects: objects, Quiet: true } }));
+      }
+      continuationToken = page.IsTruncated ? page.NextContinuationToken : undefined;
+    } while (continuationToken);
+  }
+}

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);
@@ -27,9 +28,10 @@ export class CostAnalysisReportWorker {
         reportId: report.id,
         range,
         frequency: schedule.frequency,
-        onStarted: (taskArn) => this.repository.setTaskArn(report.id, taskArn),
+        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) {