@revenium/anthropic 1.0.7 → 1.0.9

package/dist/esm/tracking.js

@@ -6,8 +6,21 @@ import { getConfig, getLogger } from "./config.js";
 import { executeWithCircuitBreaker } from "./utils/circuit-breaker.js";
 import { withRetry, ReveniumApiError, createErrorContext, handleError, } from "./utils/error-handling.js";
 import { DEFAULT_CONFIG, API_ENDPOINTS, LOGGING_CONFIG, ANTHROPIC_PATTERNS, } from "./constants.js";
+import { getEnvironment, getRegion, getCredentialAlias, getTraceType, getTraceName, detectOperationSubtype, getParentTransactionId, getTransactionName, getRetryNumber, } from "./utils/trace-fields.js";
+import { printUsageSummary } from "./utils/summary-printer.js";
 // Global logger
 const logger = getLogger();
+if (typeof process !== "undefined") {
+    process.on("uncaughtException", (error) => {
+        if (error.name === "AbortError") {
+            return;
+        }
+        if (error.stack && error.stack.includes("tracking.ts")) {
+            return;
+        }
+        throw error;
+    });
+}
 /**
  * Send tracking data to Revenium API with resilience patterns
  */
@@ -25,7 +38,8 @@ export async function sendReveniumMetrics(data) {
         isStreamed: data.isStreamed,
     });
     // Build payload using exact structure from working implementations
-    const payload = buildReveniumPayload(data);
+    // Built early so we can print summary even if Revenium tracking fails
+    const payload = await buildReveniumPayload(data);
     // Create request options
     const requestOptions = {
         method: "POST",
@@ -41,10 +55,6 @@ export async function sendReveniumMetrics(data) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), requestOptions.timeout);
     requestOptions.signal = controller.signal;
-    // Handle abort signal errors to prevent unhandled error events
-    controller.signal.addEventListener("abort", () => {
-        // Silently handle abort - this is expected behavior for timeouts
-    });
     try {
         // Execute with circuit breaker and retry logic
         await executeWithCircuitBreaker(async () => {
@@ -57,9 +67,12 @@ export async function sendReveniumMetrics(data) {
                 let response;
                 try {
                     response = await fetch(`${config.reveniumBaseUrl}${API_ENDPOINTS.AI_COMPLETIONS}`, requestOptions);
+                    if (response.body) {
+                        response.body.once("error", () => { });
+                        response.body.resume();
+                    }
                 }
                 catch (fetchError) {
-                    // Handle AbortError and other fetch errors
                     if (fetchError instanceof Error && fetchError.name === "AbortError") {
                         throw new Error(`Request timeout after ${requestOptions.timeout}ms`);
                     }
@@ -82,8 +95,19 @@ export async function sendReveniumMetrics(data) {
                     status: response.status,
                     duration: data.duration,
                 });
+                try {
+                    await response.text();
+                }
+                catch (bodyError) {
+                    logger.debug("Error reading response body (non-critical)", {
+                        requestId,
+                        error: bodyError instanceof Error
+                            ? bodyError.message
+                            : String(bodyError),
+                    });
+                }
                 return response;
-            }, config.maxRetries || DEFAULT_CONFIG.MAX_RETRIES);
+            }, config.maxRetries ?? DEFAULT_CONFIG.MAX_RETRIES);
         });
     }
     catch (error) {
@@ -93,37 +117,67 @@ export async function sendReveniumMetrics(data) {
             .withDuration(data.duration)
             .build();
         handleError(error, logger, errorContext);
-        // Always fail silently for tracking errors to prevent breaking user's application
-        // Tracking errors should never break the user's main application flow
+        // Respect failSilent configuration
+        // By default (failSilent=true), tracking errors don't break the user's application
+        // If failSilent=false, re-throw the error for user handling
+        if (config.failSilent === false) {
+            throw error;
+        }
     }
     finally {
         clearTimeout(timeoutId);
+        // Print usage summary regardless of whether Revenium tracking succeeded or failed
+        // This ensures users see the summary "after each Anthropic API request" as documented
+        printUsageSummary(payload);
     }
 }
 /**
  * Build Revenium payload from tracking data
  */
-function buildReveniumPayload(data) {
+async function buildReveniumPayload(data) {
     const now = new Date().toISOString();
     const requestTime = data.requestTime.toISOString();
     const completionStartTime = data.responseTime.toISOString();
+    // Standard known fields
+    const knownFields = new Set([
+        "taskType",
+        "agent",
+        "organizationId",
+        "productId",
+        "subscriber",
+        "subscriptionId",
+        "traceId",
+        "responseQualityScore",
+    ]);
+    // Extract custom fields (anything NOT in the standard 8 fields)
+    const customFields = {};
+    if (data.metadata) {
+        for (const [key, value] of Object.entries(data.metadata)) {
+            if (!knownFields.has(key)) {
+                customFields[key] = value;
+            }
+        }
+    }
+    const environment = getEnvironment();
+    const region = await getRegion();
+    const credentialAlias = getCredentialAlias();
+    const traceType = getTraceType();
+    const traceName = getTraceName();
+    const parentTransactionId = getParentTransactionId();
+    const transactionName = getTransactionName();
+    const retryNumber = getRetryNumber();
+    const operationSubtype = detectOperationSubtype(data.requestBody);
     return {
         stopReason: getStopReason(data.stopReason),
         costType: "AI",
         isStreamed: data.isStreamed,
-        taskType: data.metadata?.taskType,
-        agent: data.metadata?.agent,
         operationType: "CHAT",
         inputTokenCount: data.inputTokens,
         outputTokenCount: data.outputTokens,
-        reasoningTokenCount: 0, // Anthropic doesn't currently have reasoning tokens
+        reasoningTokenCount: 0,
         cacheCreationTokenCount: data.cacheCreationTokens || 0,
         cacheReadTokenCount: data.cacheReadTokens || 0,
         totalTokenCount: data.inputTokens + data.outputTokens,
-        organizationId: data.metadata?.organizationId,
-        productId: data.metadata?.productId,
-        subscriber: data.metadata?.subscriber, // Pass through nested subscriber object directly
-        subscriptionId: data.metadata?.subscriptionId,
         model: data.model,
         transactionId: data.requestId,
         responseTime: now,
@@ -132,9 +186,31 @@ function buildReveniumPayload(data) {
         requestTime: requestTime,
         completionStartTime: completionStartTime,
         timeToFirstToken: data.timeToFirstToken || 0,
-        traceId: data.metadata?.traceId,
-        responseQualityScore: data.metadata?.responseQualityScore, // Fixed: Now sending to Revenium
         middlewareSource: "nodejs",
+        ...(data.metadata?.taskType && { taskType: data.metadata.taskType }),
+        ...(data.metadata?.agent && { agent: data.metadata.agent }),
+        ...(data.metadata?.organizationId && {
+            organizationId: data.metadata.organizationId,
+        }),
+        ...(data.metadata?.productId && { productId: data.metadata.productId }),
+        ...(data.metadata?.subscriber && { subscriber: data.metadata.subscriber }),
+        ...(data.metadata?.subscriptionId && {
+            subscriptionId: data.metadata.subscriptionId,
+        }),
+        ...(data.metadata?.traceId && { traceId: data.metadata.traceId }),
+        ...(data.metadata?.responseQualityScore !== undefined && {
+            responseQualityScore: data.metadata.responseQualityScore,
+        }),
+        ...(environment && { environment }),
+        ...(region && { region }),
+        ...(credentialAlias && { credentialAlias }),
+        ...(traceType && { traceType }),
+        ...(traceName && { traceName }),
+        ...(parentTransactionId && { parentTransactionId }),
+        ...(transactionName && { transactionName }),
+        ...(retryNumber !== undefined && { retryNumber }),
+        ...(operationSubtype && { operationSubtype }),
+        ...customFields,
     };
 }
 /**
@@ -156,7 +232,6 @@ export function trackUsageAsync(trackingData) {
         return logger.warn("Revenium configuration not available - skipping tracking", {
             requestId: trackingData.requestId,
         });
-    // Run tracking in background without awaiting
     sendReveniumMetrics(trackingData)
         .then(() => {
         logger.debug("Revenium tracking completed successfully", {
@@ -166,6 +241,12 @@ export function trackUsageAsync(trackingData) {
         });
     })
         .catch((error) => {
+        if (error instanceof Error && error.name === "AbortError") {
+            logger.debug("Metrics request aborted (process exiting)", {
+                requestId: trackingData.requestId,
+            });
+            return;
+        }
         const errorContext = createErrorContext()
             .withRequestId(trackingData.requestId)
             .withModel(trackingData.model)
@@ -175,6 +256,12 @@ export function trackUsageAsync(trackingData) {
             requestId: trackingData.requestId,
             context: errorContext,
         });
+        // If failSilent=false, propagate the error
+        // Note: Since this is fire-and-forget, the error won't be caught by caller
+        // but it will appear as an unhandled promise rejection
+        if (config.failSilent === false) {
+            throw error;
+        }
     });
 }
 /**

package/dist/esm/types/anthropic-augmentation.js

@@ -18,68 +18,6 @@
  * - **Automatic Validation**: TypeScript validates the structure at compile time
  * - **Better Developer Experience**: Auto-completion and error detection
  *
- * ## Usage Examples:
- *
- * ### Basic Usage:
- * ```typescript
- * import '@revenium/anthropic';
- * import Anthropic from '@anthropic-ai/sdk';
- *
- * const anthropic = new Anthropic();
- *
- * const response = await anthropic.messages.create({
- *   model: 'claude-3-5-sonnet-latest',
- *   max_tokens: 1024,
- *   messages: [{ role: 'user', content: 'Hello!' }],
- *   usageMetadata: {  // TypeScript recognizes this natively
- *     subscriber: { id: 'user-123', email: 'user@example.com' },
- *     organizationId: 'my-company',
- *     taskType: 'customer-support',
- *     traceId: 'session-abc-123'
- *   }
- * });
- * ```
- *
- * ### Streaming Usage:
- * ```typescript
- * const stream = await anthropic.messages.stream({
- *   model: 'claude-3-5-sonnet-latest',
- *   max_tokens: 1024,
- *   messages: [{ role: 'user', content: 'Generate a report' }],
- *   usageMetadata: {
- *     taskType: 'content-generation',
- *     productId: 'report-generator',
- *     responseQualityScore: 0.95
- *   }
- * });
- * ```
- *
- * ### Advanced Usage with All Fields:
- * ```typescript
- * const response = await anthropic.messages.create({
- *   model: 'claude-3-5-sonnet-latest',
- *   max_tokens: 2048,
- *   messages: [{ role: 'user', content: 'Complex analysis task' }],
- *   usageMetadata: {
- *     subscriber: {
- *       id: 'user-456',
- *       email: 'analyst@company.com',
- *       credential: { name: 'api-key', value: 'sk-...' }
- *     },
- *     traceId: 'analysis-session-789',
- *     taskType: 'data-analysis',
- *     organizationId: 'enterprise-client',
- *     subscriptionId: 'premium-plan',
- *     productId: 'analytics-suite',
- *     agent: 'data-analyst-bot',
- *     responseQualityScore: 0.98,
- *     customField: 'custom-value'  // Extensible with custom fields
- *   }
- * });
- * ```
- *
- * @public
- * @since 1.1.0
  */
 export {};
 //# sourceMappingURL=anthropic-augmentation.js.map

package/dist/esm/utils/summary-printer.js

@@ -0,0 +1,186 @@
+import { getConfig, getLogger } from "../config.js";
+import { DEFAULT_CONFIG, SUMMARY_PRINTER_CONFIG } from "../constants.js";
+const logger = getLogger();
+function delayWithUnref(ms) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        if (typeof timer.unref === "function") {
+            timer.unref();
+        }
+    });
+}
+async function fetchCompletionMetrics(transactionId, maxRetries = SUMMARY_PRINTER_CONFIG.MAX_RETRIES, retryDelay = SUMMARY_PRINTER_CONFIG.RETRY_DELAY) {
+    const config = getConfig();
+    if (!config) {
+        logger.debug("No config available for summary printing");
+        return null;
+    }
+    if (!config.teamId) {
+        logger.debug("Team ID not configured, skipping cost retrieval for summary");
+        return null;
+    }
+    const baseUrl = (config.reveniumBaseUrl || DEFAULT_CONFIG.REVENIUM_BASE_URL).replace(/\/+$/, "");
+    const url = `${baseUrl}/profitstream/v2/api/sources/metrics/ai/completions`;
+    const teamId = config.teamId.trim();
+    const urlWithParams = `${url}?teamId=${encodeURIComponent(teamId)}&transactionId=${encodeURIComponent(transactionId)}`;
+    logger.debug("Fetching completion metrics", { url: urlWithParams });
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        // Create an AbortController with timeout to prevent hung requests from keeping Node process alive
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), SUMMARY_PRINTER_CONFIG.FETCH_TIMEOUT);
+        // Unref the timer so it doesn't keep the process alive
+        if (typeof timeoutId.unref === "function") {
+            timeoutId.unref();
+        }
+        try {
+            const response = await fetch(urlWithParams, {
+                method: "GET",
+                headers: {
+                    Accept: "application/json",
+                    "x-api-key": config.reveniumApiKey,
+                },
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                try {
+                    await response.text();
+                }
+                catch { }
+                logger.debug(`Completions metrics API returned ${response.status}`, {
+                    attempt: attempt + 1,
+                });
+                if (attempt < maxRetries - 1) {
+                    await delayWithUnref(retryDelay);
+                    continue;
+                }
+                return null;
+            }
+            const data = (await response.json());
+            const completions = data._embedded?.aICompletionMetricResourceList;
+            if (completions && completions.length > 0) {
+                return completions[0];
+            }
+            if (attempt < maxRetries - 1) {
+                logger.debug(`Waiting for metrics to aggregate (attempt ${attempt + 1}/${maxRetries})...`);
+                await delayWithUnref(retryDelay);
+            }
+        }
+        catch (error) {
+            logger.debug("Failed to fetch completion metrics", {
+                error: error instanceof Error ? error.message : String(error),
+                attempt: attempt + 1,
+            });
+            if (attempt < maxRetries - 1) {
+                await delayWithUnref(retryDelay);
+            }
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    return null;
+}
+function isSummaryFormat(value) {
+    return value === "human" || value === "json";
+}
+function formatAndPrintJsonSummary(payload, metrics) {
+    const config = getConfig();
+    const summary = {
+        model: payload.model,
+        provider: payload.provider,
+        durationSeconds: payload.requestDuration / 1000,
+        inputTokenCount: payload.inputTokenCount,
+        outputTokenCount: payload.outputTokenCount,
+        totalTokenCount: payload.totalTokenCount,
+        cost: typeof metrics?.totalCost === "number" ? metrics.totalCost : null,
+    };
+    if (summary.cost === null) {
+        summary.costStatus = config?.teamId ? "pending" : "unavailable";
+    }
+    if (payload.traceId) {
+        summary.traceId = payload.traceId;
+    }
+    console.log(JSON.stringify(summary));
+}
+function formatAndPrintHumanSummary(payload, metrics) {
+    console.log("\n" + "=".repeat(60));
+    console.log("📊 REVENIUM USAGE SUMMARY");
+    console.log("=".repeat(60));
+    console.log(`🤖 Model: ${payload.model}`);
+    console.log(`🏢 Provider: ${payload.provider}`);
+    console.log(`⏱️  Duration: ${(payload.requestDuration / 1000).toFixed(2)}s`);
+    console.log("\n💬 Token Usage:");
+    console.log(`   📥 Input Tokens:  ${(payload.inputTokenCount ?? 0).toLocaleString()}`);
+    console.log(`   📤 Output Tokens: ${(payload.outputTokenCount ?? 0).toLocaleString()}`);
+    console.log(`   📊 Total Tokens:  ${(payload.totalTokenCount ?? 0).toLocaleString()}`);
+    if (typeof metrics?.totalCost === "number") {
+        console.log(`\n💰 Cost: $${metrics.totalCost.toFixed(6)}`);
+    }
+    else {
+        const config = getConfig();
+        if (!config?.teamId) {
+            console.log(`\n💰 Cost: Set REVENIUM_TEAM_ID environment variable to see pricing`);
+        }
+        else {
+            console.log(`\n💰 Cost: (pending aggregation)`);
+        }
+    }
+    if (payload.traceId) {
+        console.log(`\n🔖 Trace ID: ${payload.traceId}`);
+    }
+    console.log("=".repeat(60) + "\n");
+}
+function formatAndPrintSummary(payload, metrics, format) {
+    if (format === "json") {
+        formatAndPrintJsonSummary(payload, metrics);
+    }
+    else {
+        formatAndPrintHumanSummary(payload, metrics);
+    }
+}
+function safeFormatAndPrintSummary(payload, metrics, format) {
+    try {
+        formatAndPrintSummary(payload, metrics, format);
+    }
+    catch (error) {
+        logger.debug("Failed to format and print summary", {
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+function getSummaryFormat(value) {
+    if (!value)
+        return null;
+    if (value === true)
+        return "human";
+    if (isSummaryFormat(value)) {
+        return value;
+    }
+    return null;
+}
+export function printUsageSummary(payload) {
+    const config = getConfig();
+    const format = getSummaryFormat(config?.printSummary);
+    if (!format) {
+        return;
+    }
+    if (config?.teamId && payload.transactionId) {
+        fetchCompletionMetrics(payload.transactionId)
+            .then((metrics) => {
+            safeFormatAndPrintSummary(payload, metrics, format);
+        })
+            .catch((error) => {
+            logger.debug("Failed to print usage summary with metrics", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            safeFormatAndPrintSummary(payload, null, format);
+        })
+            .catch(() => {
+            // Final safety catch to prevent unhandled rejections
+        });
+    }
+    else {
+        safeFormatAndPrintSummary(payload, null, format);
+    }
+}
+//# sourceMappingURL=summary-printer.js.map

package/dist/esm/utils/trace-fields.js

@@ -0,0 +1,106 @@
+import { getLogger } from "../config.js";
+const logger = getLogger();
+let cachedRegion = null;
+let regionCached = false;
+export function getEnvironment() {
+    const env = process.env.REVENIUM_ENVIRONMENT ||
+        process.env.NODE_ENV ||
+        process.env.DEPLOYMENT_ENV ||
+        null;
+    if (env && env.length > 255) {
+        logger.warn(`environment exceeds max length of 255 characters. Truncating.`);
+        return env.substring(0, 255).trim();
+    }
+    return env ? env.trim() : null;
+}
+export async function getRegion() {
+    if (regionCached) {
+        return cachedRegion;
+    }
+    const envRegion = process.env.AWS_REGION ||
+        process.env.AZURE_REGION ||
+        process.env.GCP_REGION ||
+        process.env.REVENIUM_REGION;
+    if (envRegion) {
+        cachedRegion = envRegion.trim();
+        regionCached = true;
+        return cachedRegion;
+    }
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 1000);
+        const response = await fetch("http://169.254.169.254/latest/meta-data/placement/region", {
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            cachedRegion = null;
+            regionCached = true;
+            return null;
+        }
+        const text = await response.text();
+        cachedRegion = text.trim();
+        regionCached = true;
+        return cachedRegion;
+    }
+    catch (error) {
+        cachedRegion = null;
+        regionCached = true;
+        return null;
+    }
+}
+export function getCredentialAlias() {
+    const alias = process.env.REVENIUM_CREDENTIAL_ALIAS || null;
+    if (alias && alias.length > 255) {
+        logger.warn(`credentialAlias exceeds max length of 255 characters. Truncating.`);
+        return alias.substring(0, 255).trim();
+    }
+    return alias ? alias.trim() : null;
+}
+export function getTraceType() {
+    const traceType = process.env.REVENIUM_TRACE_TYPE;
+    if (!traceType) {
+        return null;
+    }
+    if (!/^[a-zA-Z0-9_-]+$/.test(traceType)) {
+        logger.warn(`Invalid trace_type format: ${traceType}. Must be alphanumeric with hyphens/underscores only.`);
+        return null;
+    }
+    if (traceType.length > 128) {
+        logger.warn(`trace_type exceeds max length of 128 characters: ${traceType}. Truncating.`);
+        return traceType.substring(0, 128);
+    }
+    return traceType;
+}
+export function getTraceName() {
+    const traceName = process.env.REVENIUM_TRACE_NAME;
+    if (!traceName) {
+        return null;
+    }
+    if (traceName.length > 256) {
+        logger.warn(`trace_name exceeds max length of 256 characters. Truncating.`);
+        return traceName.substring(0, 256);
+    }
+    return traceName;
+}
+export function detectOperationSubtype(requestBody) {
+    if (requestBody && requestBody.tools && requestBody.tools.length > 0) {
+        return "function_call";
+    }
+    return null;
+}
+export function getParentTransactionId() {
+    return process.env.REVENIUM_PARENT_TRANSACTION_ID || null;
+}
+export function getTransactionName() {
+    return process.env.REVENIUM_TRANSACTION_NAME || null;
+}
+export function getRetryNumber() {
+    const retryNum = process.env.REVENIUM_RETRY_NUMBER;
+    if (retryNum) {
+        const parsed = parseInt(retryNum, 10);
+        return isNaN(parsed) ? 0 : parsed;
+    }
+    return 0;
+}
+//# sourceMappingURL=trace-fields.js.map