@doist/doistbot-cli 1.0.5 → 1.0.6

package/sandbox/dist/core/datadog-metrics.js

@@ -1,13 +1,18 @@
+import { createDatadogMetrics, resolveDatadogApiKey, resolveStandardObservabilityTags, } from 'doistbot-datadog-metrics';
 import { logger } from './logging.js';
 const TASK_COMPLETION_METRIC = 'doistbot.task.completion';
 const TASK_DURATION_METRIC = 'doistbot.task.duration_seconds';
-const DATADOG_REQUEST_TIMEOUT_MS = 5_000;
 let hasWarnedAboutMissingDatadogApiKey = false;
+const { postDatadogMetric } = createDatadogMetrics({ logger });
 function toTaskMetricBaseModel(model) {
     switch (model) {
+        case 'deepseek':
+            return 'deepseek';
         case 'gemini':
         case 'google':
             return 'google';
+        case 'zai':
+            return 'zai';
         case 'openai':
             return 'openai';
         case 'none':
@@ -39,57 +44,6 @@ function buildTaskMetricTags({ type, repository, model, outcome, reason, }) {
     }
     return tags;
 }
-// Doist Observability Standard requires service/env/version on metrics submitted
-// directly to the API — the host agent would otherwise inject them.
-function resolveStandardObservabilityTags() {
-    const tags = [];
-    const service = process.env.DD_SERVICE?.trim();
-    const env = process.env.DD_ENV?.trim();
-    const version = process.env.DD_VERSION?.trim();
-    if (service)
-        tags.push(`service:${service}`);
-    if (env)
-        tags.push(`env:${env}`);
-    if (version)
-        tags.push(`version:${version}`);
-    return tags;
-}
-function resolveDatadogApiKey() {
-    const apiKey = process.env.DATADOG_API_KEY?.trim();
-    return apiKey || null;
-}
-function resolveDatadogSite() {
-    return process.env.DATADOG_SITE?.trim() || process.env.DD_SITE?.trim() || 'datadoghq.com';
-}
-async function postDatadogMetric({ apiKey, path, body, }) {
-    const url = `https://api.${resolveDatadogSite()}${path}`;
-    try {
-        const response = await fetch(url, {
-            method: 'POST',
-            signal: AbortSignal.timeout(DATADOG_REQUEST_TIMEOUT_MS),
-            headers: {
-                'Content-Type': 'application/json',
-                'DD-API-KEY': apiKey,
-            },
-            body: JSON.stringify(body),
-        });
-        if (response.ok) {
-            return;
-        }
-        const errorBody = (await response.text()).slice(0, 500);
-        logger.warn('Failed to submit Datadog task metric', {
-            path,
-            status: response.status,
-            errorBody,
-        });
-    }
-    catch (error) {
-        logger.warn('Failed to submit Datadog task metric', {
-            path,
-            error: error instanceof Error ? error.message : String(error),
-        });
-    }
-}
 export async function recordTaskMetrics({ type, repository, model, outcome, durationMs, reason, }) {
     const apiKey = resolveDatadogApiKey();
     if (!apiKey) {

package/sandbox/dist/core/logger-span-processor.js

@@ -0,0 +1,78 @@
+import { SpanStatusCode, trace } from '@opentelemetry/api';
+import { logger } from './logging.js';
+const MAX_ATTR_SERIALIZED_LEN = 4096;
+export function hrTimeToMs(hrTime) {
+    const [seconds, nanos] = hrTime;
+    return Math.round(seconds * 1000 + nanos / 1_000_000);
+}
+function capString(value) {
+    if (value.length <= MAX_ATTR_SERIALIZED_LEN)
+        return value;
+    // Reserve room for the marker so the FINAL emitted value stays <= the cap.
+    const marker = `…[truncated, ${value.length} chars]`;
+    return `${value.slice(0, Math.max(0, MAX_ATTR_SERIALIZED_LEN - marker.length))}${marker}`;
+}
+export function truncateAttrs(attrs) {
+    const out = {};
+    for (const [key, value] of Object.entries(attrs)) {
+        if (key === 'doistbot.kind')
+            continue; // internal marker, never emitted
+        if (typeof value === 'string') {
+            out[key] = capString(value);
+        }
+        else if (value !== null && typeof value === 'object') {
+            // Arrays/objects (e.g. decision paths, parsed-label arrays): keep
+            // the native value if its JSON serialization is under the cap;
+            // otherwise replace it with the truncated serialized string.
+            const json = JSON.stringify(value);
+            out[key] = json.length > MAX_ATTR_SERIALIZED_LEN ? capString(json) : value;
+        }
+        else {
+            out[key] = value; // number / boolean / null — inherently small
+        }
+    }
+    return out;
+}
+// Parent span id access on a finished span is SDK-version-specific. Prefer the
+// newer `parentSpanContext`, fall back to the older `parentSpanId`. Only used
+// in onEnd — onStart derives the parent from the parent Context instead.
+function parentSpanIdOf(span) {
+    const withParentCtx = span;
+    if (withParentCtx.parentSpanContext?.spanId)
+        return withParentCtx.parentSpanContext.spanId;
+    const withParentId = span;
+    return withParentId.parentSpanId ?? null;
+}
+// Span attributes are spread FIRST so task attributes can never overwrite the
+// envelope fields (event/name/span_id/parent_span_id/duration_ms/status/error)
+// that the Datadog pipeline and the visualizer key on. Timestamps come from
+// the logging system, never from meta.
+export class LoggerSpanProcessor {
+    onStart(span, parentContext) {
+        const readable = span;
+        const isTool = readable.attributes['doistbot.kind'] === 'tool';
+        logger.info(`${isTool ? 'tool' : 'phase'}.start: ${readable.name}`, {
+            ...truncateAttrs(readable.attributes),
+            event: isTool ? 'tool.start' : 'phase.start',
+            name: readable.name,
+            span_id: readable.spanContext().spanId,
+            parent_span_id: trace.getSpanContext(parentContext)?.spanId ?? null,
+        });
+    }
+    onEnd(span) {
+        const isTool = span.attributes['doistbot.kind'] === 'tool';
+        const status = span.status.code === SpanStatusCode.ERROR ? 'error' : 'ok';
+        logger.info(`${isTool ? 'tool' : 'phase'}.end: ${span.name}`, {
+            ...truncateAttrs(span.attributes),
+            event: isTool ? 'tool.end' : 'phase.end',
+            name: span.name,
+            span_id: span.spanContext().spanId,
+            parent_span_id: parentSpanIdOf(span),
+            duration_ms: hrTimeToMs(span.duration),
+            status,
+            ...(status === 'error' && span.status.message ? { error: span.status.message } : {}),
+        });
+    }
+    async forceFlush() { }
+    async shutdown() { }
+}