@crownpeak/dqm-react-component-dev-mcp 1.2.0

package/data/probe/examples/chat/telemetry.js

@@ -0,0 +1,281 @@
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import { resourceFromAttributes } from '@opentelemetry/resources';
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from '@opentelemetry/semantic-conventions';
+import { trace, context } from '@opentelemetry/api';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { BatchSpanProcessor, ConsoleSpanExporter } from '@opentelemetry/sdk-trace-base';
+import { existsSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+import { FileSpanExporter } from './fileSpanExporter.js';
+
+/**
+ * Custom OpenTelemetry configuration for probe-chat
+ */
+export class TelemetryConfig {
+  constructor(options = {}) {
+    this.serviceName = options.serviceName || 'probe-chat';
+    this.serviceVersion = options.serviceVersion || '1.0.0';
+    this.enableFile = options.enableFile || false;
+    this.enableRemote = options.enableRemote || false;
+    this.enableConsole = options.enableConsole || false;
+    this.filePath = options.filePath || './traces.jsonl';
+    this.remoteEndpoint = options.remoteEndpoint || 'http://localhost:4318/v1/traces';
+    this.sdk = null;
+    this.tracer = null;
+  }
+
+  /**
+   * Initialize OpenTelemetry SDK
+   */
+  initialize() {
+    if (this.sdk) {
+      if (process.env.PROBE_NON_INTERACTIVE !== '1' || process.env.DEBUG_CHAT === '1') {
+        console.warn('Telemetry already initialized');
+      }
+      return;
+    }
+
+    const resource = resourceFromAttributes({
+      [ATTR_SERVICE_NAME]: this.serviceName,
+      [ATTR_SERVICE_VERSION]: this.serviceVersion,
+    });
+
+    const spanProcessors = [];
+
+    // Add file exporter if enabled
+    if (this.enableFile) {
+      try {
+        // Ensure the directory exists
+        const dir = dirname(this.filePath);
+        if (!existsSync(dir)) {
+          mkdirSync(dir, { recursive: true });
+        }
+        
+        const fileExporter = new FileSpanExporter(this.filePath);
+        // CRITICAL FIX: Configure BatchSpanProcessor with shorter delays for better span export
+        spanProcessors.push(new BatchSpanProcessor(fileExporter, {
+          // The maximum queue size. After the size is reached spans are dropped.
+          maxQueueSize: 2048,
+          // The maximum batch size of every export. It must be smaller or equal to maxQueueSize.
+          maxExportBatchSize: 512,
+          // The interval between two consecutive exports
+          scheduledDelayMillis: 500, // Reduced from default 5000ms
+          // How long the export can run before it is cancelled
+          exportTimeoutMillis: 30000,
+        }));
+        if (process.env.PROBE_NON_INTERACTIVE !== '1' || process.env.DEBUG_CHAT === '1') {
+          console.log(`[Telemetry] File exporter enabled, writing to: ${this.filePath}`);
+        }
+      } catch (error) {
+        if (process.env.PROBE_NON_INTERACTIVE !== '1' || process.env.DEBUG_CHAT === '1') {
+          console.error(`[Telemetry] Failed to initialize file exporter: ${error.message}`);
+        }
+      }
+    }
+
+    // Add remote exporter if enabled
+    if (this.enableRemote) {
+      try {
+        const remoteExporter = new OTLPTraceExporter({
+          url: this.remoteEndpoint,
+        });
+        // Configure BatchSpanProcessor with shorter delays for better span export
+        spanProcessors.push(new BatchSpanProcessor(remoteExporter, {
+          maxQueueSize: 2048,
+          maxExportBatchSize: 512,
+          scheduledDelayMillis: 500, // Reduced from default 5000ms
+          exportTimeoutMillis: 30000,
+        }));
+        if (process.env.PROBE_NON_INTERACTIVE !== '1' || process.env.DEBUG_CHAT === '1') {
+          console.log(`[Telemetry] Remote exporter enabled, endpoint: ${this.remoteEndpoint}`);
+        }
+      } catch (error) {
+        if (process.env.PROBE_NON_INTERACTIVE !== '1' || process.env.DEBUG_CHAT === '1') {
+          console.error(`[Telemetry] Failed to initialize remote exporter: ${error.message}`);
+        }
+      }
+    }
+
+    // Add console exporter if enabled (useful for debugging)
+    if (this.enableConsole) {
+      const consoleExporter = new ConsoleSpanExporter();
+      // Configure BatchSpanProcessor with shorter delays for better span export
+      spanProcessors.push(new BatchSpanProcessor(consoleExporter, {
+        maxQueueSize: 2048,
+        maxExportBatchSize: 512,
+        scheduledDelayMillis: 500, // Reduced from default 5000ms
+        exportTimeoutMillis: 30000,
+      }));
+      if (process.env.PROBE_NON_INTERACTIVE !== '1' || process.env.DEBUG_CHAT === '1') {
+        console.log(`[Telemetry] Console exporter enabled`);
+      }
+    }
+
+    if (spanProcessors.length === 0) {
+      if (process.env.PROBE_NON_INTERACTIVE !== '1' || process.env.DEBUG_CHAT === '1') {
+        console.log('[Telemetry] No exporters configured, telemetry will not be collected');
+      }
+      return;
+    }
+
+    this.sdk = new NodeSDK({
+      resource,
+      spanProcessors,
+    });
+
+    try {
+      this.sdk.start();
+      this.tracer = trace.getTracer(this.serviceName, this.serviceVersion);
+      if (process.env.PROBE_NON_INTERACTIVE !== '1' || process.env.DEBUG_CHAT === '1') {
+        console.log(`[Telemetry] OpenTelemetry SDK initialized successfully`);
+      }
+    } catch (error) {
+      if (process.env.PROBE_NON_INTERACTIVE !== '1' || process.env.DEBUG_CHAT === '1') {
+        console.error(`[Telemetry] Failed to start OpenTelemetry SDK: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * Get the tracer instance
+   */
+  getTracer() {
+    return this.tracer;
+  }
+
+  /**
+   * Create a span with the given name and attributes
+   */
+  createSpan(name, attributes = {}) {
+    if (!this.tracer) {
+      return null;
+    }
+
+    return this.tracer.startSpan(name, {
+      attributes,
+    });
+  }
+
+  /**
+   * Wrap a function to automatically create spans
+   */
+  wrapFunction(name, fn, attributes = {}) {
+    if (!this.tracer) {
+      return fn;
+    }
+
+    return async (...args) => {
+      const span = this.createSpan(name, attributes);
+      if (!span) {
+        return fn(...args);
+      }
+
+      try {
+        const result = await context.with(trace.setSpan(context.active(), span), () => fn(...args));
+        span.setStatus({ code: trace.SpanStatusCode.OK });
+        return result;
+      } catch (error) {
+        span.setStatus({
+          code: trace.SpanStatusCode.ERROR,
+          message: error.message,
+        });
+        span.recordException(error);
+        throw error;
+      } finally {
+        span.end();
+      }
+    };
+  }
+
+  /**
+   * Force flush all pending spans
+   */
+  async forceFlush() {
+    if (this.sdk) {
+      try {
+        // Get the active tracer provider
+        const tracerProvider = trace.getTracerProvider();
+        
+        if (tracerProvider && typeof tracerProvider.forceFlush === 'function') {
+          // Call forceFlush on the tracer provider
+          await tracerProvider.forceFlush();
+          
+          if (process.env.DEBUG_CHAT === '1') {
+            console.log('[Telemetry] TracerProvider flushed successfully');
+          }
+        }
+        
+        // Also try to access registered span processors directly for better control
+        if (tracerProvider._registeredSpanProcessors) {
+          const flushPromises = [];
+          
+          for (const processor of tracerProvider._registeredSpanProcessors) {
+            if (typeof processor.forceFlush === 'function') {
+              flushPromises.push(processor.forceFlush());
+            }
+          }
+          
+          if (flushPromises.length > 0) {
+            await Promise.all(flushPromises);
+            
+            if (process.env.DEBUG_CHAT === '1') {
+              console.log(`[Telemetry] Directly flushed ${flushPromises.length} span processors`);
+            }
+          }
+        }
+        
+        // Add a small delay to ensure file writes complete
+        await new Promise(resolve => setTimeout(resolve, 100));
+        
+        if (process.env.DEBUG_CHAT === '1') {
+          console.log('[Telemetry] OpenTelemetry spans flushed successfully');
+        }
+      } catch (error) {
+        if (process.env.PROBE_NON_INTERACTIVE !== '1' || process.env.DEBUG_CHAT === '1') {
+          console.error(`[Telemetry] Failed to flush OpenTelemetry spans: ${error.message}`);
+        }
+      }
+    }
+  }
+
+  /**
+   * Shutdown telemetry
+   */
+  async shutdown() {
+    if (this.sdk) {
+      try {
+        await this.sdk.shutdown();
+        if (process.env.PROBE_NON_INTERACTIVE !== '1' || process.env.DEBUG_CHAT === '1') {
+          console.log('[Telemetry] OpenTelemetry SDK shutdown successfully');
+        }
+      } catch (error) {
+        if (process.env.PROBE_NON_INTERACTIVE !== '1' || process.env.DEBUG_CHAT === '1') {
+          console.error(`[Telemetry] Failed to shutdown OpenTelemetry SDK: ${error.message}`);
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Default telemetry configuration
+ */
+export const defaultTelemetryConfig = new TelemetryConfig();
+
+/**
+ * Initialize telemetry from environment variables
+ */
+export function initializeTelemetryFromEnv() {
+  const config = new TelemetryConfig({
+    serviceName: process.env.OTEL_SERVICE_NAME || 'probe-chat',
+    serviceVersion: process.env.OTEL_SERVICE_VERSION || '1.0.0',
+    enableFile: process.env.OTEL_ENABLE_FILE === 'true',
+    enableRemote: process.env.OTEL_ENABLE_REMOTE === 'true',
+    enableConsole: process.env.OTEL_ENABLE_CONSOLE === 'true',
+    filePath: process.env.OTEL_FILE_PATH || './traces.jsonl',
+    remoteEndpoint: process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT || 'http://localhost:4318/v1/traces',
+  });
+
+  config.initialize();
+  return config;
+}

package/data/probe/examples/chat/test/integration/chatFlows.test.js

@@ -0,0 +1,320 @@
+import { describe, it, before, after, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { 
+    setupTestEnvironment, 
+    createTestProbeChat, 
+    captureConsoleOutput,
+    runChatInteraction,
+    testData 
+} from '../testUtils.js';
+import { mockResponses } from '../mocks/mockLLMProvider.js';
+
+describe('Chat Flow Integration Tests', () => {
+    let testEnv;
+    let consoleCapture;
+    
+    before(() => {
+        testEnv = setupTestEnvironment();
+    });
+    
+    after(() => {
+        testEnv.restore();
+    });
+    
+    beforeEach(() => {
+        consoleCapture = captureConsoleOutput();
+    });
+    
+    afterEach(() => {
+        consoleCapture.restore();
+    });
+    
+    describe('Basic Chat Interactions', () => {
+        it('should handle simple text conversation', async () => {
+            const { probeChat, mockProvider } = await createTestProbeChat({
+                responses: [
+                    { text: 'Hello! I am a mock AI assistant.' },
+                    { text: 'The weather is simulated to be sunny.' }
+                ]
+            });
+            
+            const messages = [
+                { role: 'user', content: 'Hello' },
+                { role: 'user', content: 'How is the weather?' }
+            ];
+            
+            const results = await runChatInteraction(probeChat, messages);
+            
+            assert.strictEqual(results.responses.length, 2);
+            assert.strictEqual(results.errors.length, 0);
+            assert.ok(results.streamedText.includes('Hello! I am a mock AI assistant.'));
+            assert.ok(results.streamedText.includes('The weather is simulated to be sunny.'));
+        });
+        
+        it('should handle streaming responses', async () => {
+            const { probeChat } = await createTestProbeChat({
+                responses: [mockResponses.longStreamingResponse]
+            });
+            
+            let streamChunks = [];
+            const results = await runChatInteraction(probeChat, 
+                [{ role: 'user', content: 'Tell me a story' }],
+                {
+                    onStream: (chunk) => {
+                        streamChunks.push(chunk);
+                    }
+                }
+            );
+            
+            assert.strictEqual(results.errors.length, 0);
+            assert.ok(streamChunks.length > 1, 'Should receive multiple stream chunks');
+            assert.ok(results.streamedText.includes('longer response'));
+            assert.ok(results.streamedText.includes('streamed in chunks'));
+        });
+        
+        it('should handle conversation context', async () => {
+            const { probeChat, mockProvider } = await createTestProbeChat({
+                responses: [
+                    { text: 'My name is MockBot.' },
+                    { text: 'You asked me about my name. I told you it is MockBot.' }
+                ]
+            });
+            
+            // First message
+            await probeChat.sendMessage('What is your name?');
+            
+            // Second message should have context
+            await probeChat.sendMessage('What did I just ask you?');
+            
+            // Check that the context was maintained
+            const capturedCalls = mockProvider.capturedCalls;
+            assert.strictEqual(capturedCalls.length, 2);
+            
+            // Second call should include previous messages
+            const secondCallMessages = capturedCalls[1].messages;
+            assert.ok(secondCallMessages.length >= 3); // user, assistant, user
+            assert.strictEqual(secondCallMessages[0].content, 'What is your name?');
+        });
+    });
+    
+    describe('Error Handling', () => {
+        it('should handle API errors gracefully', async () => {
+            const { probeChat } = await createTestProbeChat({
+                mockProvider: {
+                    throwError: 'Simulated API error'
+                }
+            });
+            
+            const results = await runChatInteraction(probeChat, 
+                [{ role: 'user', content: 'This should fail' }]
+            );
+            
+            assert.strictEqual(results.errors.length, 1);
+            assert.ok(results.errors[0].message.includes('Simulated API error'));
+        });
+        
+        it('should handle timeout scenarios', async () => {
+            const { probeChat } = await createTestProbeChat({
+                responses: [{ text: 'This will timeout' }],
+                chatOptions: {
+                    timeout: 100 // 100ms timeout
+                },
+                mockProvider: {
+                    streamDelay: 200 // 200ms delay per chunk
+                }
+            });
+            
+            const startTime = Date.now();
+            const results = await runChatInteraction(probeChat, 
+                [{ role: 'user', content: 'Test timeout' }]
+            );
+            const duration = Date.now() - startTime;
+            
+            // Should timeout before completing the full stream
+            assert.ok(duration < 1000, 'Should timeout quickly');
+        });
+        
+        it('should recover from errors and continue conversation', async () => {
+            const { probeChat, mockProvider } = await createTestProbeChat({
+                responses: [
+                    { text: 'First response works' },
+                    { text: 'Second response (will be skipped due to error)' },
+                    { text: 'Third response after recovery' }
+                ]
+            });
+            
+            // Override getNextResponse to simulate error on second call
+            let callCount = 0;
+            const originalGetNext = mockProvider.getNextResponse;
+            mockProvider.getNextResponse = function() {
+                callCount++;
+                if (callCount === 2) {
+                    // Advance the response index so the third call gets the correct response
+                    this.currentResponseIndex = (this.currentResponseIndex + 1) % this.responses.length;
+                    throw new Error('Simulated error on second call');
+                }
+                return originalGetNext.call(this);
+            };
+            
+            const messages = [
+                { role: 'user', content: 'First message' },
+                { role: 'user', content: 'This will error' },
+                { role: 'user', content: 'Should work again' }
+            ];
+            
+            const results = await runChatInteraction(probeChat, messages);
+            
+            // Verify the chat system recovered correctly
+            assert.strictEqual(results.responses.length, 2, 'Should have 2 successful responses');
+            assert.strictEqual(results.errors.length, 1, 'Should have 1 error');
+            assert.ok(results.streamedText.includes('First response works'), 'First response should be included');
+            assert.ok(results.streamedText.includes('Third response after recovery'), 'Third response should be included after recovery');
+            assert.ok(results.errors[0].message.includes('Simulated error on second call'), 'Error should be captured correctly');
+        });
+    });
+    
+    describe('Multi-turn Conversations', () => {
+        it('should maintain conversation history', async () => {
+            const { probeChat, mockProvider } = await createTestProbeChat({
+                responses: [
+                    { text: 'I can help you with coding.' },
+                    { text: 'You asked about my capabilities. I mentioned coding help.' },
+                    { text: 'Throughout our conversation, you asked about capabilities and I explained coding help.' }
+                ]
+            });
+            
+            // Build conversation
+            await probeChat.sendMessage('What can you help with?');
+            await probeChat.sendMessage('What did I ask about?');
+            await probeChat.sendMessage('Summarize our conversation');
+            
+            const calls = mockProvider.capturedCalls;
+            assert.ok(calls.length >= 3, 'Should have at least 3 calls');
+            
+            // Find the actual chat calls (not duplicates)
+            const chatCalls = [];
+            const seenMessageCounts = new Set();
+            for (const call of calls) {
+                const msgCount = call.messages.length;
+                if (!seenMessageCounts.has(msgCount)) {
+                    seenMessageCounts.add(msgCount);
+                    chatCalls.push(call);
+                }
+            }
+            
+            assert.strictEqual(chatCalls.length, 3, 'Should have 3 unique chat calls');
+            
+            // Check conversation growth
+            assert.strictEqual(chatCalls[0].messages.length, 1); // Just user message
+            assert.strictEqual(chatCalls[1].messages.length, 3); // user, assistant, user
+            assert.strictEqual(chatCalls[2].messages.length, 5); // full conversation
+        });
+        
+        it('should handle conversation reset', async () => {
+            const { probeChat, mockProvider } = await createTestProbeChat({
+                responses: [
+                    { text: 'First conversation response' },
+                    { text: 'Fresh start response' }
+                ]
+            });
+            
+            // First conversation
+            await probeChat.sendMessage('First message');
+            
+            // Reset conversation using clearHistory (the actual method)
+            const newSessionId = probeChat.clearHistory();
+            assert.ok(newSessionId, 'clearHistory should return a new session ID');
+            
+            // New conversation
+            await probeChat.sendMessage('New conversation');
+            
+            const calls = mockProvider.capturedCalls;
+            assert.strictEqual(calls.length, 2);
+            
+            // Second call should not have history from first
+            assert.strictEqual(calls[1].messages.length, 1);
+            assert.strictEqual(calls[1].messages[0].content, 'New conversation');
+        });
+    });
+    
+    describe('System Prompts and Configuration', () => {
+        it('should include system prompts in conversation', async () => {
+            const systemPrompt = 'You are a helpful coding assistant specialized in JavaScript.';
+            const { probeChat, mockProvider } = await createTestProbeChat({
+                responses: [{ text: 'I understand JavaScript very well.' }],
+                chatOptions: {
+                    systemPrompt
+                }
+            });
+            
+            await probeChat.sendMessage('Can you help with JS?');
+            
+            const call = mockProvider.capturedCalls[0];
+            assert.ok(call.system || call.messages.some(m => m.role === 'system'));
+            
+            if (call.system) {
+                assert.strictEqual(call.system, systemPrompt);
+            } else {
+                const systemMessage = call.messages.find(m => m.role === 'system');
+                assert.ok(systemMessage);
+                assert.strictEqual(systemMessage.content, systemPrompt);
+            }
+        });
+        
+        it('should respect temperature and max tokens settings', async () => {
+            const { probeChat, mockProvider } = await createTestProbeChat({
+                responses: [{ text: 'Temperature test response' }],
+                chatOptions: {
+                    temperature: 0.7,
+                    maxTokens: 2000
+                }
+            });
+            
+            await probeChat.sendMessage('Test message');
+            
+            const call = mockProvider.capturedCalls[0];
+            assert.strictEqual(call.temperature, 0.7);
+            assert.strictEqual(call.maxTokens, 2000);
+        });
+    });
+    
+    describe('Image Support', () => {
+        it('should handle image inputs in messages', async () => {
+            const { probeChat, mockProvider } = await createTestProbeChat({
+                responses: [{ text: 'I can see the image you provided.' }]
+            });
+            
+            const messageWithImage = {
+                role: 'user',
+                content: [
+                    { type: 'text', text: 'What is in this image?' },
+                    { type: 'image', image: 'base64encodedimage' }
+                ]
+            };
+            
+            await runChatInteraction(probeChat, [messageWithImage]);
+            
+            const call = mockProvider.capturedCalls[0];
+            assert.ok(Array.isArray(call.messages[0].content));
+            assert.strictEqual(call.messages[0].content[0].type, 'text');
+            assert.strictEqual(call.messages[0].content[1].type, 'image');
+        });
+        
+        it('should process image URLs', async () => {
+            const { probeChat, mockProvider } = await createTestProbeChat({
+                responses: [{ text: 'I processed the image from the URL.' }]
+            });
+            
+            // Mock the processImageUrl method
+            probeChat.processImageUrl = async (url) => {
+                return 'mocked-base64-image-data';
+            };
+            
+            await probeChat.sendMessage('Look at this image: https://example.com/image.png');
+            
+            const call = mockProvider.capturedCalls[0];
+            // The message should be processed to include image data
+            assert.ok(call.messages[0].content);
+        });
+    });
+});