add payload to the exporter

Author: sharon77242

packages/agent/src/export/exporter.ts

@@ -128,7 +128,8 @@ export class OTLPExporter {
       const durationMs = event.metricName === "memory-leak" ? 0 : event.value;
 
       return {
-        traceId: crypto.randomBytes(16).toString("hex"),
+        traceId:
+          (event.payload.traceId as string | undefined) ?? crypto.randomBytes(16).toString("hex"),
         spanId: crypto.randomBytes(8).toString("hex"),
         name: event.metricName,
         kind: 1, // SPAN_KIND_INTERNAL

packages/agent/src/export/otlp-compatible-exporter.ts

@@ -50,7 +50,10 @@ export class OTLPCompatibleExporter {
     const nowNsStr = nowNs.toString();
 
     const dataPoints = events.map((e) => ({
-      attributes: [{ key: "metric.name", value: { stringValue: e.metricName } }],
+      attributes: [
+        { key: "metric.name", value: { stringValue: e.metricName } },
+        { key: "argus.payload", value: { stringValue: JSON.stringify(e.payload) } },
+      ],
       startTimeUnixNano: nowNsStr,
       timeUnixNano: nowNsStr,
       asDouble: e.value,

packages/agent/tests/export/exporter.test.ts

@@ -34,6 +34,42 @@ describe("OTLPExporter", () => {
     );
   });
 
+  it("uses traceId from payload when present instead of generating a random one", () => {
+    const exporter = new OTLPExporter({
+      endpointUrl: "https://localhost",
+      key: "test",
+      cert: "test",
+      ca: "test",
+    });
+
+    const knownTraceId = "a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4";
+    const events: AggregatorEvent[] = [
+      { id: "1", metricName: "query", value: 50, payload: { traceId: knownTraceId } },
+    ];
+
+    const payload = exporter.formatToOTLP(events);
+    const span = payload.resourceSpans[0].scopeSpans[0].spans[0];
+
+    assert.strictEqual(span.traceId, knownTraceId);
+  });
+
+  it("falls back to a random traceId when payload has no traceId", () => {
+    const exporter = new OTLPExporter({
+      endpointUrl: "https://localhost",
+      key: "test",
+      cert: "test",
+      ca: "test",
+    });
+
+    const events: AggregatorEvent[] = [{ id: "1", metricName: "query", value: 50, payload: {} }];
+
+    const payload = exporter.formatToOTLP(events);
+    const span = payload.resourceSpans[0].scopeSpans[0].spans[0];
+
+    assert.ok(span.traceId.length === 32, "fallback traceId must be 32 hex chars");
+    assert.ok(/^[0-9a-f]+$/.test(span.traceId), "fallback traceId must be hex");
+  });
+
   // Bug: retry delay used retryDelayMs * attempt (linear) but JSDoc promised "doubles each attempt".
   // With maxRetries=3 the 3rd retry diverges: linear gives 300ms, exponential gives 400ms.
   it("should use exponential backoff — delay doubles each retry attempt", async () => {

packages/agent/tests/export/otlp-compatible-exporter.test.ts

@@ -152,6 +152,57 @@ describe("OTLPCompatibleExporter", () => {
     }
   });
 
+  it("data points include argus.payload attribute with full event payload as JSON", async () => {
+    let receivedBody = "";
+    const server = http.createServer((req, res) => {
+      let d = "";
+      req.on("data", (c) => {
+        d += String(c);
+      });
+      req.on("end", () => {
+        receivedBody = d;
+        res.writeHead(200).end();
+      });
+    });
+
+    await new Promise<void>((r) => server.listen(0, "127.0.0.1", r));
+    const { port } = server.address() as { port: number };
+
+    try {
+      const exporter = new OTLPCompatibleExporter({
+        endpointUrl: `http://127.0.0.1:${port}/v1/metrics`,
+      });
+      const payload = { sanitizedQuery: "SELECT ?", suggestions: [{ message: "add index" }] };
+      await exporter.export([makeEvent({ payload })]);
+
+      const parsed = JSON.parse(receivedBody) as {
+        resourceMetrics: [
+          {
+            scopeMetrics: [
+              {
+                metrics: [
+                  {
+                    gauge: {
+                      dataPoints: {
+                        attributes: { key: string; value: { stringValue: string } }[];
+                      }[];
+                    };
+                  },
+                ];
+              },
+            ];
+          },
+        ];
+      };
+      const dp = parsed.resourceMetrics[0].scopeMetrics[0].metrics[0].gauge.dataPoints[0];
+      const payloadAttr = dp.attributes.find((a) => a.key === "argus.payload");
+      assert.ok(payloadAttr, "argus.payload attribute must be present");
+      assert.deepStrictEqual(JSON.parse(payloadAttr.value.stringValue), payload);
+    } finally {
+      await new Promise<void>((r) => server.close(() => r()));
+    }
+  });
+
   it("OTLP body contains service.name attribute", async () => {
     let receivedBody = "";
     const server = http.createServer((req, res) => {