Add missing truncateValue export, fix review comments

- Export truncateValue and MAX_ATTRIBUTE_LENGTH from core index.ts
- Add shared truncateValue with suffix-aware truncation to tracing/util.ts
- Remove local truncateValue copies from OpenAI and LangChain Utils.ts
- Warn when LangChain singleton getInstance() receives options after init
- Fix misleading test name for content recording
- Add truncation tests, token cache cap tests, JWT TTL cap tests

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

Author: jsl517

packages/agents-a365-observability-extensions-langchain/src/Utils.ts

@@ -3,16 +3,7 @@
 
 import { Run } from "@langchain/core/tracers/base";
 import { Span } from "@opentelemetry/api";
-import { OpenTelemetryConstants } from "@microsoft/agents-a365-observability";
-
-const MAX_ATTRIBUTE_LENGTH = 8_192;
-
-function truncateValue(value: string): string {
-  if (value.length > MAX_ATTRIBUTE_LENGTH) {
-    return value.substring(0, MAX_ATTRIBUTE_LENGTH) + '...[truncated]';
-  }
-  return value;
-}
+import { OpenTelemetryConstants, truncateValue } from "@microsoft/agents-a365-observability";
 
 // Type guards
 export function isString(value: unknown): value is string {

packages/agents-a365-observability-extensions-openai/src/Utils.ts

@@ -3,7 +3,7 @@
 // ------------------------------------------------------------------------------
 
 import { SpanStatusCode } from '@opentelemetry/api';
-import { OpenTelemetryConstants } from '@microsoft/agents-a365-observability';
+import { OpenTelemetryConstants, truncateValue } from '@microsoft/agents-a365-observability';
 import * as Constants from './Constants';
 import { Span as AgentsSpan, SpanData } from '@openai/agents-core/dist/tracing/spans';
 
@@ -12,20 +12,11 @@ import { Span as AgentsSpan, SpanData } from '@openai/agents-core/dist/tracing/s
  * @param obj - The object to stringify
  * @returns JSON string representation or string conversion if JSON.stringify fails
  */
-const MAX_ATTRIBUTE_LENGTH = 8_192;
-
-function truncateValue(value: string): string {
-  if (value.length > MAX_ATTRIBUTE_LENGTH) {
-    return value.substring(0, MAX_ATTRIBUTE_LENGTH) + '...[truncated]';
-  }
-  return value;
-}
-
 export function safeJsonDumps(obj: unknown): string {
   try {
     return truncateValue(JSON.stringify(obj));
   } catch {
-    return String(obj);
+    return truncateValue(String(obj));
   }
 }
 

packages/agents-a365-observability/src/index.ts

@@ -55,6 +55,7 @@ export { InferenceScope } from './tracing/scopes/InferenceScope';
 export { OutputScope } from './tracing/scopes/OutputScope';
 export { logger, setLogger, getLogger, resetLogger, formatError } from './utils/logging';
 export type { ILogger } from './utils/logging';
+export { truncateValue, MAX_ATTRIBUTE_LENGTH } from './tracing/util';
 
 // Exporter utilities
 export { isPerRequestExportEnabled } from './tracing/exporter/utils';

packages/agents-a365-observability/src/tracing/util.ts

@@ -21,3 +21,25 @@ export const isAgent365ExporterEnabled = (
   const provider = configProvider ?? defaultObservabilityConfigurationProvider;
   return provider.getConfiguration().isObservabilityExporterEnabled;
 };
+
+/**
+ * Maximum length for span attribute values.
+ * Values exceeding this limit will be truncated with a suffix.
+ */
+export const MAX_ATTRIBUTE_LENGTH = 8_192;
+
+const TRUNCATION_SUFFIX = '...[truncated]';
+
+/**
+ * Truncate a string value to {@link MAX_ATTRIBUTE_LENGTH} characters.
+ * If the value exceeds the limit, it is trimmed and a truncation suffix is appended,
+ * with the total length capped at exactly {@link MAX_ATTRIBUTE_LENGTH}.
+ * @param value The string to truncate
+ * @returns The original string if within limits, otherwise the truncated string
+ */
+export function truncateValue(value: string): string {
+  if (value.length > MAX_ATTRIBUTE_LENGTH) {
+    return value.substring(0, MAX_ATTRIBUTE_LENGTH - TRUNCATION_SUFFIX.length) + TRUNCATION_SUFFIX;
+  }
+  return value;
+}

tests/observability/extension/hosting/agentic-token-cache.test.ts

@@ -156,4 +156,67 @@ describe('AgenticTokenCacheInstance', () => {
     const tokenAfter = AgenticTokenCacheInstance.getObservabilityToken('agentE', 'tenantE');
     expect(tokenAfter).toBeNull();
   });
+
+  it('evicts oldest entry when cache exceeds max size', async () => {
+    const { AgenticTokenCache } = require('@microsoft/agents-a365-observability-hosting');
+    const cache = new AgenticTokenCache();
+    const map = (cache as any)._map as Map<string, any>;
+
+    // Pre-fill the map to capacity
+    const MAX = (cache as any)._maxCacheSize as number;
+    for (let i = 0; i < MAX; i++) {
+      map.set(`agent-${i}:tenant-${i}`, { scopes: ['s'], token: `t-${i}`, acquiredOn: Date.now() });
+    }
+    expect(map.size).toBe(MAX);
+
+    // Insert one more via RefreshObservabilityToken
+    const token = makeJwtWithExp(300);
+    const auth = makeAuthorizationMock([{ token }]);
+    await cache.RefreshObservabilityToken(
+      'agent-new',
+      'tenant-new',
+      asTurnContext(makeTurnContext()),
+      auth as any,
+      ['scope.read']
+    );
+
+    // Size should still be at MAX (oldest evicted, new one added)
+    expect(map.size).toBe(MAX);
+    // First entry should have been evicted
+    expect(map.has('agent-0:tenant-0')).toBe(false);
+    // New entry should exist
+    expect(map.has('agent-new:tenant-new')).toBe(true);
+  });
+
+  it('caps JWT exp claim to 24 hours', async () => {
+    const { AgenticTokenCache } = require('@microsoft/agents-a365-observability-hosting');
+    const cache = new AgenticTokenCache();
+
+    // Create JWT with exp 48 hours from now
+    const farFutureExp = Math.floor(Date.now() / 1000) + (48 * 60 * 60);
+    const header = Buffer.from(JSON.stringify({ alg: 'none', typ: 'JWT' })).toString('base64url');
+    const payload = Buffer.from(JSON.stringify({ exp: farFutureExp })).toString('base64url');
+    const farFutureToken = `${header}.${payload}.sig`;
+
+    const auth = makeAuthorizationMock([{ token: farFutureToken }]);
+    await cache.RefreshObservabilityToken(
+      'agent-exp',
+      'tenant-exp',
+      asTurnContext(makeTurnContext()),
+      auth as any,
+      ['scope.read']
+    );
+
+    const map = (cache as any)._map as Map<string, any>;
+    const entry = map.get('agent-exp:tenant-exp');
+    expect(entry).toBeDefined();
+    expect(entry.expiresOn).toBeDefined();
+
+    // The expiresOn should be capped to ~24 hours from now (not 48 hours)
+    const maxAllowed = Date.now() + (24 * 60 * 60 * 1000) + 5000; // 24h + small tolerance
+    expect(entry.expiresOn).toBeLessThanOrEqual(maxAllowed);
+    // And should be well below the 48-hour uncapped value
+    const uncapped = farFutureExp * 1000;
+    expect(entry.expiresOn).toBeLessThan(uncapped);
+  });
 });

tests/observability/extension/openai/OpenAIAgentsTraceProcessor.test.ts

@@ -503,7 +503,7 @@ describe('OpenAIAgentsTraceProcessor', () => {
       expect(keys).not.toContain(OpenTelemetryConstants.GEN_AI_INPUT_MESSAGES_KEY);
     });
 
-    it('records GEN_AI_INPUT_MESSAGES when enabled (default)', async () => {
+    it('records GEN_AI_INPUT_MESSAGES when content recording is enabled', async () => {
       const processor = new OpenAIAgentsTraceProcessor(tracer, { isContentRecordingEnabled: true });
       const traceData = { traceId: 'trace-allow', name: 'Agent' } as any;
       await processor.onTraceStart(traceData);

tests/observability/tracing/truncation.test.ts

@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { describe, it, expect } from '@jest/globals';
+import { truncateValue, MAX_ATTRIBUTE_LENGTH } from '../../../packages/agents-a365-observability/src/tracing/util';
+
+describe('truncateValue', () => {
+  const SUFFIX = '...[truncated]';
+
+  it('should return the original string when within limit', () => {
+    const value = 'hello world';
+    expect(truncateValue(value)).toBe(value);
+  });
+
+  it('should return the original string when exactly at limit', () => {
+    const value = 'x'.repeat(MAX_ATTRIBUTE_LENGTH);
+    expect(truncateValue(value)).toBe(value);
+    expect(truncateValue(value).length).toBe(MAX_ATTRIBUTE_LENGTH);
+  });
+
+  it('should truncate when 1 character over limit', () => {
+    const value = 'x'.repeat(MAX_ATTRIBUTE_LENGTH + 1);
+    const result = truncateValue(value);
+    expect(result.length).toBe(MAX_ATTRIBUTE_LENGTH);
+    expect(result.endsWith(SUFFIX)).toBe(true);
+  });
+
+  it('should truncate long strings to exactly MAX_ATTRIBUTE_LENGTH', () => {
+    const value = 'a'.repeat(MAX_ATTRIBUTE_LENGTH * 2);
+    const result = truncateValue(value);
+    expect(result.length).toBe(MAX_ATTRIBUTE_LENGTH);
+    expect(result.endsWith(SUFFIX)).toBe(true);
+  });
+
+  it('should preserve the beginning of the string when truncating', () => {
+    const prefix = 'PREFIX_';
+    const value = prefix + 'x'.repeat(MAX_ATTRIBUTE_LENGTH);
+    const result = truncateValue(value);
+    expect(result.startsWith(prefix)).toBe(true);
+  });
+
+  it('should return empty string unchanged', () => {
+    expect(truncateValue('')).toBe('');
+  });
+});
+
+describe('MAX_ATTRIBUTE_LENGTH', () => {
+  it('should be 8192', () => {
+    expect(MAX_ATTRIBUTE_LENGTH).toBe(8_192);
+  });
+});