refactor(integration-tests): rename telemetry types and simplify metrics

- Rename DatadogTelemetry -> InvocationTracesLogs (per-invocation data)
- Rename RuntimeTelemetry -> DatadogTelemetry (aggregated telemetry)
- Remove redundant getMetricPoints wrapper
- Remove metricsApiAvailable graceful degradation

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: jchrostek-dd

integration-tests/tests/lmi.test.ts

@@ -1,5 +1,5 @@
 import { invokeAndCollectTelemetry, FunctionConfig } from './utils/default';
-import { RuntimeTelemetry } from './utils/datadog';
+import { DatadogTelemetry } from './utils/datadog';
 import { getIdentifier } from '../config';
 
 const runtimes = ['node', 'python', 'java', 'dotnet'] as const;
@@ -9,7 +9,7 @@ const identifier = getIdentifier();
 const stackName = `integ-${identifier}-lmi`;
 
 describe('LMI Integration Tests', () => {
-  let telemetry: Record<string, RuntimeTelemetry>;
+  let telemetry: Record<string, DatadogTelemetry>;
 
   beforeAll(async () => {
     const functions: FunctionConfig[] = runtimes.map(runtime => ({

integration-tests/tests/on-demand.test.ts

@@ -1,5 +1,5 @@
 import { invokeAndCollectTelemetry, FunctionConfig } from './utils/default';
-import { RuntimeTelemetry, MetricPoint, ENHANCED_METRICS_CONFIG, isMetricsApiAvailable } from './utils/datadog';
+import { DatadogTelemetry, MetricPoint, ENHANCED_METRICS_CONFIG } from './utils/datadog';
 import { forceColdStart } from './utils/lambda';
 import { getIdentifier } from '../config';
 
@@ -10,7 +10,7 @@ const identifier = getIdentifier();
 const stackName = `integ-${identifier}-on-demand`;
 
 describe('On-Demand Integration Tests', () => {
-  let telemetry: Record<string, RuntimeTelemetry>;
+  let telemetry: Record<string, DatadogTelemetry>;
 
   beforeAll(async () => {
     const functions: FunctionConfig[] = runtimes.map(runtime => ({
@@ -23,7 +23,7 @@ describe('On-Demand Integration Tests', () => {
 
     // Add 5s delay between invocations to ensure warm container is reused
     // Required because there is post-runtime processing with 'end' flush strategy
-    // invokeAndCollectTelemetry now returns RuntimeTelemetry with metrics included
+    // invokeAndCollectTelemetry now returns DatadogTelemetry with metrics included
     telemetry = await invokeAndCollectTelemetry(functions, 2, 1, 5000);
 
     console.log('All invocations and data fetching completed');
@@ -155,15 +155,6 @@ describe('On-Demand Integration Tests', () => {
     });
 
     describe('duration metrics', () => {
-      // Helper to check if metrics API is available and skip if not
-      const skipIfNoMetricsApi = () => {
-        if (!isMetricsApiAvailable()) {
-          console.log('⚠️  Skipping metrics test - API unavailable (missing timeseries_query scope)');
-          return true;
-        }
-        return false;
-      };
-
       // Helper to get latest value from points
       const getLatestValue = (points: MetricPoint[]) =>
         points.length > 0 ? points[points.length - 1].value : null;
@@ -175,7 +166,6 @@ describe('On-Demand Integration Tests', () => {
 
       describe.each(durationMetrics)('%s', (metricName) => {
         it('should be emitted', () => {
-          if (skipIfNoMetricsApi()) return;
           const { duration } = getTelemetry().metrics;
           // Metrics may not be indexed in the query time window for all runtimes
           if (duration[metricName].length === 0) {
@@ -186,7 +176,6 @@ describe('On-Demand Integration Tests', () => {
         });
 
         it('should have a positive value', () => {
-          if (skipIfNoMetricsApi()) return;
           const { duration } = getTelemetry().metrics;
           const value = getLatestValue(duration[metricName]);
           // Skip if no data available
@@ -201,14 +190,12 @@ describe('On-Demand Integration Tests', () => {
       // Count validation
       describe('count validation', () => {
         it('should emit runtime_duration for each invocation', () => {
-          if (skipIfNoMetricsApi()) return;
           const { duration } = getTelemetry().metrics;
           // Enhanced metrics may aggregate points, so we check >= 1 instead of exact count
           expect(duration['runtime_duration'].length).toBeGreaterThanOrEqual(1);
         });
 
         it('should emit init_duration only on cold start', () => {
-          if (skipIfNoMetricsApi()) return;
           const { duration } = getTelemetry().metrics;
           // init_duration should exist for cold start (may be 0 or 1 depending on runtime/timing)
           // Some runtimes may not emit init_duration in all cases
@@ -220,7 +207,6 @@ describe('On-Demand Integration Tests', () => {
 
       // Relationship tests
       it('duration and runtime_duration should be comparable', () => {
-        if (skipIfNoMetricsApi()) return;
         const { duration } = getTelemetry().metrics;
         const durationValue = getLatestValue(duration['duration']);
         const runtimeValue = getLatestValue(duration['runtime_duration']);
@@ -238,7 +224,6 @@ describe('On-Demand Integration Tests', () => {
       });
 
       it('post_runtime_duration should be reasonable', () => {
-        if (skipIfNoMetricsApi()) return;
         const { duration } = getTelemetry().metrics;
         const value = getLatestValue(duration['post_runtime_duration']);
         // Skip if metric has no data

integration-tests/tests/otlp.test.ts

@@ -1,5 +1,5 @@
 import { invokeAndCollectTelemetry, FunctionConfig } from './utils/default';
-import { RuntimeTelemetry } from './utils/datadog';
+import { DatadogTelemetry } from './utils/datadog';
 import { getIdentifier, DATADOG_INDEXING_WAIT_5_MIN_MS } from '../config';
 
 const runtimes = ['node', 'python', 'java', 'dotnet'] as const;
@@ -9,7 +9,7 @@ const identifier = getIdentifier();
 const stackName = `integ-${identifier}-otlp`;
 
 describe('OTLP Integration Tests', () => {
-  let telemetry: Record<string, RuntimeTelemetry>;
+  let telemetry: Record<string, DatadogTelemetry>;
 
   beforeAll(async () => {
     // Build function configs for all runtimes plus response validation

integration-tests/tests/snapstart.test.ts

@@ -1,5 +1,5 @@
 import { invokeAndCollectTelemetry, FunctionConfig } from './utils/default';
-import { RuntimeTelemetry } from './utils/datadog';
+import { DatadogTelemetry } from './utils/datadog';
 import { publishVersion, waitForSnapStartReady } from './utils/lambda';
 import { getIdentifier } from '../config';
 
@@ -10,7 +10,7 @@ const identifier = getIdentifier();
 const stackName = `integ-${identifier}-snapstart`;
 
 describe('Snapstart Integration Tests', () => {
-  let telemetry: Record<string, RuntimeTelemetry>;
+  let telemetry: Record<string, DatadogTelemetry>;
 
   beforeAll(async () => {
     // Publish new versions and wait for SnapStart optimization

integration-tests/tests/utils/datadog.ts

@@ -55,6 +55,11 @@ function formatDatadogError(error: unknown, query: string): string {
 }
 
 export interface DatadogTelemetry {
+  threads: InvocationTracesLogs[][];  // [thread][invocation]
+  metrics: EnhancedMetrics;
+}
+
+export interface InvocationTracesLogs {
   requestId: string;
   statusCode?: number;
   traces?: DatadogTrace[];
@@ -78,6 +83,27 @@ export interface DatadogLog {
   tags: string[];
 }
 
+export const ENHANCED_METRICS_CONFIG = {
+  duration: [
+    'aws.lambda.enhanced.runtime_duration',
+    'aws.lambda.enhanced.billed_duration',
+    'aws.lambda.enhanced.duration',
+    'aws.lambda.enhanced.post_runtime_duration',
+    'aws.lambda.enhanced.init_duration',
+  ],
+} as const;
+
+export type MetricCategory = keyof typeof ENHANCED_METRICS_CONFIG;
+
+export type EnhancedMetrics = {
+  [K in MetricCategory]: Record<string, MetricPoint[]>;
+};
+
+export interface MetricPoint {
+  timestamp: number;
+  value: number;
+}
+
 /**
  * Extracts the base service name from a function name by stripping any
  * version qualifier (:N) or alias qualifier (:alias)
@@ -90,7 +116,7 @@ function getServiceName(functionName: string): string {
   return functionName.substring(0, colonIndex);
 }
 
-export async function getDatadogTelemetryByRequestId(functionName: string, requestId: string): Promise<DatadogTelemetry> {
+export async function getInvocationTracesLogsByRequestId(functionName: string, requestId: string): Promise<InvocationTracesLogs> {
   const serviceName = getServiceName(functionName);
   const traces = await getTraces(serviceName, requestId);
   const logs = await getLogs(serviceName, requestId);
@@ -256,53 +282,6 @@ export async function getLogs(
   }
 }
 
-// ============================================================================
-// Enhanced Metrics
-// ============================================================================
-
-/**
- * Configuration for which metrics to fetch.
- * Add new metrics here - no code changes needed.
- */
-export const ENHANCED_METRICS_CONFIG = {
-  duration: [
-    'aws.lambda.enhanced.runtime_duration',
-    'aws.lambda.enhanced.billed_duration',
-    'aws.lambda.enhanced.duration',
-    'aws.lambda.enhanced.post_runtime_duration',
-    'aws.lambda.enhanced.init_duration',
-  ],
-  // Future categories - just add metric names:
-  // memory: [
-  //   'aws.lambda.enhanced.max_memory_used',
-  //   'aws.lambda.enhanced.memory_size',
-  // ],
-} as const;
-
-export type MetricCategory = keyof typeof ENHANCED_METRICS_CONFIG;
-
-export interface MetricPoint {
-  timestamp: number;
-  value: number;
-}
-
-/**
- * Wrapper combining per-invocation telemetry with aggregated metrics.
- * Threads are preserved for tests that use concurrency > 1.
- */
-export interface RuntimeTelemetry {
-  threads: DatadogTelemetry[][];  // [thread][invocation]
-  metrics: EnhancedMetrics;
-}
-
-/**
- * Enhanced metrics organized by category.
- * Each category maps metric names to their points (for count validation).
- */
-export type EnhancedMetrics = {
-  [K in MetricCategory]: Record<string, MetricPoint[]>;
-};
-
 /**
  * Fetch all enhanced metrics for a function based on config
  */
@@ -345,7 +324,7 @@ async function fetchMetricCategory(
   toTime: number
 ): Promise<Record<string, MetricPoint[]>> {
   const promises = metricNames.map(async (metricName) => {
-    const points = await getMetricPoints(metricName, functionName, fromTime, toTime);
+    const points = await getMetrics(metricName, functionName, fromTime, toTime);
     // Use short name (last part after the last dot)
     const shortName = metricName.split('.').pop()!;
     return { shortName, points };
@@ -361,84 +340,39 @@ async function fetchMetricCategory(
   return metrics;
 }
 
-// Track if metrics API is available (set once on first failure)
-let metricsApiAvailable: boolean | null = null;
-
 /**
  * Query Datadog Metrics API v1 for a specific metric.
  * Requires the DD_API_KEY to have 'timeseries_query' scope.
- * Returns empty array if API is unavailable (permissions issue).
  */
 async function getMetrics(
   metricName: string,
   functionName: string,
   fromTime: number,
   toTime: number
 ): Promise<MetricPoint[]> {
-  // Skip if we've already determined the API is unavailable
-  if (metricsApiAvailable === false) {
-    return [];
-  }
-
-  try {
-    const functionNameLower = functionName.toLowerCase();
-    const query = `avg:${metricName}{functionname:${functionNameLower}}`;
+  const functionNameLower = functionName.toLowerCase();
+  const query = `avg:${metricName}{functionname:${functionNameLower}}`;
 
-    console.log(`Querying metrics: ${query}`);
+  console.log(`Querying metrics: ${query}`);
 
-    const response = await datadogClient.get('/api/v1/query', {
-      params: {
-        query,
-        from: Math.floor(fromTime / 1000),
-        to: Math.floor(toTime / 1000),
-      },
-    });
-
-    metricsApiAvailable = true;
+  const response = await datadogClient.get('/api/v1/query', {
+    params: {
+      query,
+      from: Math.floor(fromTime / 1000),
+      to: Math.floor(toTime / 1000),
+    },
+  });
 
-    const series = response.data.series || [];
-    console.log(`Found ${series.length} series for ${metricName}`);
+  const series = response.data.series || [];
+  console.log(`Found ${series.length} series for ${metricName}`);
 
-    if (series.length === 0) {
-      return [];
-    }
-
-    // Return points from first series
-    return (series[0].pointlist || []).map((p: [number, number]) => ({
-      timestamp: p[0],
-      value: p[1],
-    }));
-  } catch (error: any) {
-    const errorData = error.response?.data;
-    // Check if this is a permissions error
-    if (errorData?.errors?.some((e: string) => e.includes('Forbidden') || e.includes('permission'))) {
-      if (metricsApiAvailable === null) {
-        console.warn('⚠️  Metrics API unavailable (missing timeseries_query scope). Metrics tests will be skipped.');
-        console.warn('   To enable metrics tests, ensure DD_API_KEY has the timeseries_query scope.');
-      }
-      metricsApiAvailable = false;
-      return [];
-    }
-    console.error('Error querying metrics:', errorData || error.message);
-    throw error;
+  if (series.length === 0) {
+    return [];
   }
-}
-
-/**
- * Check if metrics API is available
- */
-export function isMetricsApiAvailable(): boolean {
-  return metricsApiAvailable === true;
-}
 
-/**
- * Get all metric points in time window
- */
-async function getMetricPoints(
-  metricName: string,
-  functionName: string,
-  fromTime: number,
-  toTime: number
-): Promise<MetricPoint[]> {
-  return getMetrics(metricName, functionName, fromTime, toTime);
+  // Return points from first series
+  return (series[0].pointlist || []).map((p: [number, number]) => ({
+    timestamp: p[0],
+    value: p[1],
+  }));
 }