@smythos/sre 1.7.40 → 1.7.42

package/src/subsystems/ObservabilityManager/Telemetry.service/connectors/OTel/OTel.class.ts

@@ -5,7 +5,7 @@ import { IAccessCandidate } from '@sre/types/ACL.types';
 import { TelemetryConnector } from '../../TelemetryConnector';
 import { AgentCallLog } from '@sre/types/AgentLogger.types';
 
-import { trace, context, SpanStatusCode, Tracer } from '@opentelemetry/api';
+import { trace, context, SpanStatusCode, Tracer, propagation } from '@opentelemetry/api';
 import { Logger as OTelLogger, logs, SeverityNumber } from '@opentelemetry/api-logs';
 import { OTelContextRegistry } from './OTelContextRegistry';
 import { HookService, THook } from '@sre/Core/HookService';
@@ -62,6 +62,10 @@ export class OTel extends TelemetryConnector {
 
     constructor(protected _settings: OTelLogConfig) {
         super();
+        if (!_settings.endpoint) {
+            outputLogger.warn('OTel initialization skipped, endpoint is not set');
+            return;
+        }
 
         outputLogger.log(`Initializing Tracer ...`);
 
@@ -279,6 +283,7 @@ export class OTel extends TelemetryConnector {
                         attributes: {
                             'agent.id': hookContext.agentId,
                             'conv.id': hookContext.processId,
+                            'team.id': hookContext.teamId,
                             'llm.model': modelId || 'unknown',
                         },
                     },
@@ -312,6 +317,7 @@ export class OTel extends TelemetryConnector {
                         attributes: {
                             'agent.id': hookContext.agentId,
                             'conv.id': hookContext.processId,
+                            'team.id': hookContext.teamId,
                             'request.id': reqInfo.requestId,
                             'llm.model': modelId || 'unknown',
                             'metric.type': 'ttfb',
@@ -331,11 +337,21 @@ export class OTel extends TelemetryConnector {
         HookService.register(
             'Conversation.streamPrompt',
             async function (additionalContext, args) {
-                const conversation: Conversation = this.instance;
-                const processId = conversation.id;
+                const conversation: Conversation = this.instance; //this.instance.agentData.teamId // this.instance.agentData.parenparentTeamId //this.instance.agentData.planInfo.properties this.instance.agentData.planInfo.flags
+                const processId = conversation.storeId || conversation.id;
                 const agentId = conversation.agentId;
                 const message = typeof args === 'object' ? args?.message : args || null;
                 const hookContext: any = this.context;
+                const teamId = conversation.agentData.teamId;
+                const orgTier = 'standard';
+                const orgSlot = this.instance.agentData?.planInfo?.flags ? `standard/${teamId}` : undefined;
+                const agentData = conversation.agentData || {};
+                const isDebugSession = agentData.debugSessionEnabled || false;
+                const isTestDomain = agentData.usingTestDomain || false;
+                const sessionId = processId;
+                const workflowId = agentData?.workflowReqId || agentData?.workflowID || agentData?.workflowId || undefined;
+                const logTags = agentData?.sessionTag || (isDebugSession ? 'DEBUG' : undefined);
+
                 if (message == null) {
                     //this is a conversation step, will be handled by createRequestedHandler
 
@@ -354,14 +370,36 @@ export class OTel extends TelemetryConnector {
                         'gen_ai.conversation.id': processId,
                         'gen_ai.request.model': modelId || 'unknown',
                         ////////////////////////////////
+                        'team.id': teamId,
+                        'org.tier': orgTier,
+                        'org.slot': orgSlot,
                         'agent.id': agentId,
                         'conv.id': processId,
                         'llm.model': modelId || 'unknown',
+                        'agent.debug': isDebugSession,
+                        'agent.isTest': isTestDomain,
+                        'session.id': sessionId,
+                        'workflow.id': workflowId,
                     },
                 });
                 hookContext.convSpan = convSpan;
                 hookContext.agentId = agentId;
                 hookContext.processId = processId;
+                hookContext.teamId = teamId;
+                hookContext.orgSlot = orgSlot;
+                hookContext.isDebugSession = isDebugSession;
+                hookContext.isTestDomain = isTestDomain;
+
+                // Inject trace context into conversation headers for distributed tracing
+                let headers = {};
+                const traceContext = trace.setSpan(context.active(), convSpan);
+                propagation.inject(traceContext, headers);
+                for (let [key, value] of Object.entries(headers)) {
+                    conversation.headers[key] = value as string;
+                }
+                if (OTEL_DEBUG_LOGS) {
+                    outputLogger.debug('Injected trace headers into conversation', { processId, headers });
+                }
 
                 hookContext.dataHandler = createDataHandler(hookContext);
                 conversation.on(TLLMEvent.Data, hookContext.dataHandler);
@@ -395,10 +433,19 @@ export class OTel extends TelemetryConnector {
                             span_id: spanCtx.spanId,
                             trace_flags: spanCtx.traceFlags,
 
+                            /////
+                            'team.id': teamId,
+                            'org.slot': orgSlot,
+
                             'agent.id': agentId,
                             'conv.id': processId,
                             'input.size': JSON.stringify(message || {}).length,
                             'input.preview': message.substring(0, 2000),
+                            'agent.debug': isDebugSession,
+                            'agent.isTest': isTestDomain,
+                            'session.id': sessionId,
+                            'workflow.id': workflowId,
+                            'log.tags': logTags,
                         },
                     });
                 });
@@ -410,10 +457,21 @@ export class OTel extends TelemetryConnector {
             'Conversation.streamPrompt',
             async function ({ result, args, error }) {
                 const conversation: Conversation = this.instance;
-                const processId = conversation.id;
+                const processId = conversation.storeId || conversation.id;
                 const agentId = conversation.agentId;
                 const message = typeof args?.[0] === 'object' ? args?.[0]?.message : args?.[0] || null;
                 const hookContext: any = this.context;
+                const teamId = conversation.agentData.teamId;
+                const orgTier = 'standard';
+                const orgSlot = this.instance.agentData?.planInfo?.flags ? `standard/${teamId}` : undefined;
+
+                const isDebugSession = hookContext.isDebugSession || conversation.agentData?.debugSessionEnabled || false;
+                const isTestDomain = hookContext.isTestDomain || conversation.agentData?.usingTestDomain || false;
+                const agentData = conversation.agentData || {};
+                const sessionId = processId;
+                const workflowId = agentData?.workflowReqId || agentData?.workflowID || agentData?.workflowId || undefined;
+                const logTags = agentData?.sessionTag || (isDebugSession ? 'DEBUG' : undefined);
+
                 if (message == null) {
                     return;
                 }
@@ -424,10 +482,14 @@ export class OTel extends TelemetryConnector {
                 const accessCandidate = AccessCandidate.agent(agentId);
                 if (OTEL_DEBUG_LOGS) outputLogger.debug('Conversation.streamPrompt completed', { processId }, accessCandidate);
 
+                // Handle curLLMGenSpan with error awareness
                 if (hookContext.curLLMGenSpan) {
+                    if (error) {
+                        hookContext.curLLMGenSpan.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+                    }
                     hookContext.curLLMGenSpan.addEvent('llm.gen.content', {
                         'content.size': JSON.stringify(result || {}).length,
-                        'content.preview': result.substring(0, 200),
+                        'content.preview': typeof result === 'string' ? result.substring(0, 200) : JSON.stringify(result || {}).substring(0, 200),
                     });
                     hookContext.curLLMGenSpan.end();
 
@@ -440,19 +502,69 @@ export class OTel extends TelemetryConnector {
 
                 const spanCtx = convSpan.spanContext();
                 const spanContext = trace.setSpan(context.active(), convSpan);
-                context.with(spanContext, () => {
-                    logger.emit({
-                        severityNumber: SeverityNumber.INFO,
-                        severityText: 'INFO',
-                        body: `Conversation.streamPrompt completed: ${processId}`,
-                        attributes: {
-                            'agent.id': agentId,
-                            'conv.id': processId,
-                            'output.size': JSON.stringify(result || {}).length,
-                            'output.preview': result.substring(0, 2000),
-                        },
+
+                if (error) {
+                    // Error handling for conversation span
+                    convSpan.recordException(error);
+                    convSpan.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+                    convSpan.addEvent('conv.error', {
+                        'error.message': error.message,
                     });
-                });
+
+                    // Emit ERROR log
+                    context.with(spanContext, () => {
+                        logger.emit({
+                            severityNumber: SeverityNumber.ERROR,
+                            severityText: 'ERROR',
+                            body: `Conversation.streamPrompt failed: ${processId}`,
+                            attributes: {
+                                // Explicit trace correlation
+                                trace_id: spanCtx.traceId,
+                                span_id: spanCtx.spanId,
+                                trace_flags: spanCtx.traceFlags,
+
+                                'agent.id': agentId,
+                                'conv.id': processId,
+                                'error.message': error.message,
+                                'error.stack': error.stack,
+                                'team.id': teamId,
+                                'org.tier': orgTier,
+                                'org.slot': orgSlot,
+                                'agent.debug': isDebugSession,
+                                'agent.isTest': isTestDomain,
+                                'session.id': sessionId,
+                                'workflow.id': workflowId,
+                                'log.tags': logTags,
+                            },
+                        });
+                    });
+                } else {
+                    // Success handling
+                    convSpan.setStatus({ code: SpanStatusCode.OK });
+
+                    context.with(spanContext, () => {
+                        logger.emit({
+                            severityNumber: SeverityNumber.INFO,
+                            severityText: 'INFO',
+                            body: `Conversation.streamPrompt completed: ${processId}`,
+                            attributes: {
+                                'agent.id': agentId,
+                                'conv.id': processId,
+                                'output.size': JSON.stringify(result || {}).length,
+                                'output.preview':
+                                    typeof result === 'string' ? result.substring(0, 2000) : JSON.stringify(result || {}).substring(0, 2000),
+                                'team.id': teamId,
+                                'org.tier': orgTier,
+                                'org.slot': orgSlot,
+                                'agent.debug': isDebugSession,
+                                'agent.isTest': isTestDomain,
+                                'session.id': sessionId,
+                                'workflow.id': workflowId,
+                                'log.tags': logTags,
+                            },
+                        });
+                    });
+                }
 
                 convSpan.end();
 
@@ -471,11 +583,21 @@ export class OTel extends TelemetryConnector {
                 const conversationId = agent.conversationId || agent.agentRequest?.header('X-CONVERSATION-ID');
                 const processId = agentProcessId.split(':').shift();
 
+                const orgTier = 'standard';
+                const orgSlot = agent.data.planInfo?.flags ? `standard/${agent.data.teamId}` : undefined;
                 const agentId = agent.id;
                 const agentRequest = agent.agentRequest;
                 const teamId = agent.teamId;
                 const _hookContext: any = this.context;
 
+                const sessionId = agent.callerSessionId || undefined;
+                const workflowId = agent.agentRuntime?.workflowReqId || undefined;
+
+                const isDebugSession = agent.debugSessionEnabled || agent.agentRuntime?.debug || false;
+                const logTags = agent.sessionTag || (isDebugSession ? 'DEBUG' : undefined);
+                const isTestDomain = agent.usingTestDomain || false;
+                const domain = agent.domain || undefined;
+
                 const accessCandidate = AccessCandidate.agent(agentId);
                 if (OTEL_DEBUG_LOGS) outputLogger.debug('SREAgent.process started', { processId, agentProcessId, endpointPath }, accessCandidate);
 
@@ -487,22 +609,50 @@ export class OTel extends TelemetryConnector {
                 const input = { body, query, headers, processInput: agentInput };
 
                 let convSpan;
-                const ctx = OTelContextRegistry.get(agentId, processId) || OTelContextRegistry.get(agentId, conversationId);
+                let parentContext = context.active();
+
+                //try reading ctx from local registry (local execution)
+                let ctx = OTelContextRegistry.get(agentId, processId) || OTelContextRegistry.get(agentId, conversationId);
 
                 if (ctx) {
                     convSpan = ctx.rootSpan;
                     _hookContext.otelSpan = convSpan;
+                    parentContext = trace.setSpan(context.active(), convSpan);
+                } else {
+                    // No local context found - try extracting from headers (remote execution)
+                    const extractedContext = propagation.extract(context.active(), agentRequest.headers);
+                    const extractedSpan = trace.getSpan(extractedContext);
+
+                    if (extractedSpan) {
+                        // Successfully extracted parent span from headers
+                        parentContext = extractedContext;
+                        if (OTEL_DEBUG_LOGS) {
+                            outputLogger.debug('SREAgent.process extracted remote parent context from headers', {
+                                processId,
+                                traceId: extractedSpan.spanContext().traceId,
+                            });
+                        }
+                    }
                 }
+
                 const agentSpan = tracer.startSpan(
                     'Agent.Skill',
                     {
                         attributes: {
                             'agent.id': agentId,
                             'team.id': teamId,
+                            'conv.id': conversationId,
                             'process.id': agentProcessId,
+                            'org.slot': orgSlot,
+                            'org.tier': orgTier,
+                            'session.id': sessionId,
+                            'workflow.id': workflowId,
+                            'agent.debug': isDebugSession,
+                            'agent.isTest': isTestDomain,
+                            'agent.domain': domain,
                         },
                     },
-                    convSpan ? trace.setSpan(context.active(), convSpan) : undefined
+                    parentContext
                 );
 
                 // Add start event
@@ -528,12 +678,22 @@ export class OTel extends TelemetryConnector {
                             trace_id: spanCtx.traceId,
                             span_id: spanCtx.spanId,
                             trace_flags: spanCtx.traceFlags,
-                            agentId,
-                            processId: agentProcessId,
+                            'agent.id': agentId,
+                            'process.id': agentProcessId,
                             input: agentInput,
                             body,
                             query,
                             headers,
+                            'team.id': teamId,
+                            'org.slot': orgSlot,
+                            'org.tier': orgTier,
+                            'conv.id': conversationId,
+                            'session.id': sessionId,
+                            'workflow.id': workflowId,
+                            'log.tags': logTags,
+                            'agent.debug': isDebugSession,
+                            'agent.isTest': isTestDomain,
+                            'agent.domain': domain,
                         },
                     } as any);
                 });
@@ -546,8 +706,20 @@ export class OTel extends TelemetryConnector {
             async function ({ result, error }) {
                 const agent = this.instance;
                 const agentProcessId = agent.agentRuntime.processID; // nested process has a subID that needs to be removed
+                const conversationId = agent.conversationId || agent.agentRequest?.header('X-CONVERSATION-ID');
                 const agentId = agent.id;
                 const _hookContext: any = this.context;
+                const teamId = agent.teamId;
+                const orgTier = 'standard';
+                const orgSlot = agent.data.planInfo?.flags ? `standard/${agent.data.teamId}` : undefined;
+
+                const sessionId = agent.callerSessionId || undefined;
+                const workflowId = agent.agentRuntime?.workflowReqId || undefined;
+
+                const isDebugSession = agent.debugSessionEnabled || agent.agentRuntime?.debug || false;
+                const logTags = agent.sessionTag || (isDebugSession ? 'DEBUG' : undefined);
+                const isTestDomain = agent.usingTestDomain || false;
+                const domain = agent.domain || undefined;
 
                 const ctx = OTelContextRegistry.get(agentId, agentProcessId);
                 if (!ctx) return;
@@ -558,12 +730,32 @@ export class OTel extends TelemetryConnector {
                 const accessCandidate = AccessCandidate.agent(agentId);
                 if (OTEL_DEBUG_LOGS) outputLogger.debug('SREAgent.process completed', { agentProcessId }, accessCandidate);
 
+                // Check for error indicators in result (process returned error without throwing)
+                const hasResultError = !error && (!!result?._error || !!result?.error);
+                const resultError = hasResultError ? result._error || result.error : null;
+                const resultErrorMessage = resultError?.message || (typeof resultError === 'string' ? resultError : null);
+
+                // Determine if this is an error case (either thrown error or result error)
+                const isError = !!error || hasResultError;
+                const errorMessage = error?.message || resultErrorMessage || 'Process returned error';
+
                 if (error) {
                     agentSpan.recordException(error);
                     agentSpan.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
                     agentSpan.addEvent('skill.process.error', {
                         'error.message': error.message,
                     });
+                } else if (hasResultError) {
+                    // Handle error in result (no exception thrown)
+                    agentSpan.setStatus({ code: SpanStatusCode.ERROR, message: errorMessage });
+                    agentSpan.addEvent('skill.process.error', {
+                        'error.message': errorMessage,
+                        'error.type': 'result_error',
+                    });
+                    agentSpan.setAttributes({
+                        'output.size': JSON.stringify(result || {}).length,
+                        'output.has_error': true,
+                    });
                 } else {
                     agentSpan.setStatus({ code: SpanStatusCode.OK });
                     agentSpan.addEvent('skill.process.completed', {
@@ -575,18 +767,29 @@ export class OTel extends TelemetryConnector {
                 }
 
                 // Emit log BEFORE ending span to ensure context is active
-                const outputForLog = oTelInstance.formatOutputForLog(result, !!error);
+                const outputForLog = oTelInstance.formatOutputForLog(result, isError);
                 const spanCtx = agentSpan.spanContext();
                 const logAttributes: Record<string, any> = {
                     // Explicit trace correlation (some backends need these)
                     trace_id: spanCtx.traceId,
                     span_id: spanCtx.spanId,
                     trace_flags: spanCtx.traceFlags,
-                    agentId,
-                    processId: agentProcessId,
-                    hasError: !!error,
-                    'error.message': error?.message,
+                    'agent.id': agentId,
+                    'process.id': agentProcessId,
+                    hasError: isError,
+                    'error.message': isError ? errorMessage : undefined,
                     'error.stack': error?.stack,
+                    'error.type': hasResultError ? 'result_error' : undefined,
+                    'team.id': teamId,
+                    'org.slot': orgSlot,
+                    'org.tier': orgTier,
+                    'conv.id': conversationId,
+                    'session.id': sessionId,
+                    'workflow.id': workflowId,
+                    'log.tags': logTags,
+                    'agent.debug': isDebugSession,
+                    'agent.isTest': isTestDomain,
+                    'agent.domain': domain,
                 };
 
                 // Only include output if formatOutputForLog returns a value
@@ -598,9 +801,9 @@ export class OTel extends TelemetryConnector {
                 const spanContext = trace.setSpan(context.active(), agentSpan);
                 context.with(spanContext, () => {
                     logger.emit({
-                        severityNumber: error ? SeverityNumber.ERROR : SeverityNumber.INFO,
-                        severityText: error ? 'ERROR' : 'INFO',
-                        body: `Agent process ${error ? 'failed' : 'completed'}: ${agentProcessId}`,
+                        severityNumber: isError ? SeverityNumber.ERROR : SeverityNumber.INFO,
+                        severityText: isError ? 'ERROR' : 'INFO',
+                        body: `Agent process ${isError ? 'failed' : 'completed'}: ${agentProcessId}`,
                         attributes: logAttributes,
                     } as any);
                 });
@@ -625,7 +828,27 @@ export class OTel extends TelemetryConnector {
                 const componentName = settings.displayName || settings.name;
                 const eventId = settings.eventId; // specific event id attached to this component execution
                 const accessCandidate = AccessCandidate.agent(agentId);
-                if (OTEL_DEBUG_LOGS) outputLogger.debug('Component.process started', { componentId }, accessCandidate);
+                const teamId = agent.teamId;
+                const orgTier = 'standard';
+                const orgSlot = agent.data.planInfo?.flags ? `standard/${agent.data.teamId}` : undefined;
+
+                const componentData = agent.agentRuntime?.getComponentData?.(componentId);
+                const sourceId = componentData?.sourceId || 'AGENT';
+                const sourceComponentData = sourceId !== 'AGENT' ? agent.components?.[sourceId] : null;
+                const sourceName = sourceComponentData?.displayName || sourceComponentData?.name || sourceId;
+
+                const sessionId = agent.callerSessionId || undefined;
+                const workflowId = agent.agentRuntime?.workflowReqId || undefined;
+                const workflowStep = agent.agentRuntime?.curStep || undefined;
+
+                const isDebugSession = agent.debugSessionEnabled || agent.agentRuntime?.debug || false;
+                const logTags = agent.sessionTag || (isDebugSession ? 'DEBUG' : undefined);
+                const isTestDomain = agent.usingTestDomain || false;
+
+                const inputAction = input?.__action || undefined;
+                const inputStatus = input?.__status || undefined;
+
+                if (OTEL_DEBUG_LOGS) outputLogger.debug('Component.process started', { componentId, sourceId }, accessCandidate);
 
                 const ctx = OTelContextRegistry.get(agentId, processId);
                 const parentSpan = ctx?.rootSpan;
@@ -642,13 +865,23 @@ export class OTel extends TelemetryConnector {
                             'cmp.id': componentId,
                             'cmp.type': componentType,
                             'cmp.name': componentName,
+                            'team.id': teamId,
+                            'org.tier': orgTier,
+                            'org.slot': orgSlot,
+                            'source.id': sourceId,
+                            'source.name': sourceName,
+                            'session.id': sessionId,
+                            'workflow.id': workflowId,
+                            'workflow.step': workflowStep,
+                            'agent.debug': isDebugSession,
+                            'agent.isTest': isTestDomain,
                             ...compSettingsData,
                         },
                     },
                     parentSpan ? trace.setSpan(context.active(), parentSpan) : undefined
                 );
 
-                // Add event: Component started
+                // Add event: Component started - includes input.action and input.status for workflow tracking
                 const inputStr = JSON.stringify(input || {});
 
                 const compInputData = oTelInstance.prepareComponentData(input || {});
@@ -656,6 +889,8 @@ export class OTel extends TelemetryConnector {
                     'event.id': eventId,
                     'cmp.input.size': JSON.stringify(input || {}).length,
                     'cmp.input': JSON.stringify(compInputData),
+                    'input.action': inputAction,
+                    'input.status': inputStatus,
                 });
 
                 // Emit structured log with full details
@@ -673,6 +908,17 @@ export class OTel extends TelemetryConnector {
                             'cmp.type': componentType,
                             'cmp.name': componentName,
                             'cmp.input': input,
+                            'team.id': teamId,
+                            'org.slot': orgSlot,
+                            'org.tier': orgTier,
+                            'source.id': sourceId,
+                            'source.name': sourceName,
+                            'session.id': sessionId,
+                            'workflow.id': workflowId,
+                            'workflow.step': workflowStep,
+                            'log.tags': logTags,
+                            'agent.debug': isDebugSession,
+                            'agent.isTest': isTestDomain,
                         },
                     });
                 });
@@ -699,6 +945,22 @@ export class OTel extends TelemetryConnector {
                 const componentId = settings.id || 'unknown';
                 const componentType = settings.name;
                 const componentName = settings.displayName || settings.name;
+                const teamId = agent.teamId;
+                const orgTier = 'standard';
+                const orgSlot = agent.data.planInfo?.flags ? `standard/${agent.data.teamId}` : undefined;
+
+                const componentData = agent.agentRuntime?.getComponentData?.(componentId);
+                const sourceId = componentData?.sourceId || 'AGENT';
+                const sourceComponentData = sourceId !== 'AGENT' ? agent.components?.[sourceId] : null;
+                const sourceName = sourceComponentData?.displayName || sourceComponentData?.name || sourceId;
+
+                const sessionId = agent.callerSessionId || undefined;
+                const workflowId = agent.agentRuntime?.workflowReqId || undefined;
+                const workflowStep = agent.agentRuntime?.curStep || undefined;
+
+                const isDebugSession = agent.debugSessionEnabled || agent.agentRuntime?.debug || false;
+                const logTags = agent.sessionTag || (isDebugSession ? 'DEBUG' : undefined);
+                const isTestDomain = agent.usingTestDomain || false;
 
                 const accessCandidate = AccessCandidate.agent(agentId);
                 if (OTEL_DEBUG_LOGS) outputLogger.debug('Component.process completed', { componentId }, accessCandidate);
@@ -736,51 +998,125 @@ export class OTel extends TelemetryConnector {
                                 'error.type': error.name,
                                 'error.message': error.message,
                                 'error.stack': error.stack, // ← Full stack in logs
+                                'team.id': teamId,
+                                'org.slot': orgSlot,
+                                'org.tier': orgTier,
+                                'source.id': sourceId,
+                                'source.name': sourceName,
+                                'session.id': sessionId,
+                                'workflow.id': workflowId,
+                                'workflow.step': workflowStep,
+                                'log.tags': logTags,
+                                'agent.debug': isDebugSession,
+                                'agent.isTest': isTestDomain,
                             },
                         });
                     });
                 } else {
-                    span.setStatus({ code: SpanStatusCode.OK });
-
-                    // Add success event with output summary
+                    // Check if result contains an error indicator (component returned error without throwing)
+                    const hasResultError = !!result?._error || !!result?.error;
                     const resultStr = JSON.stringify(result || {});
-                    span.addEvent('cmp.call.result', {
-                        'output.size': resultStr.length,
-                        'output.preview': resultStr.substring(0, 200),
-                    });
 
-                    // Add output attributes to span
-                    span.setAttributes({
-                        'output.size': JSON.stringify(result || {}).length,
-                        'output.has_error': !!result?._error,
-                    });
+                    if (hasResultError) {
+                        // Treat as error even though no exception was thrown
+                        const resultError = result._error || result.error;
+                        const errorMessage = resultError?.message || (typeof resultError === 'string' ? resultError : 'Component returned error');
 
-                    // Emit success log with output (formatted safely)
-                    const outputForLog = oTelInstance.formatOutputForLog(result, false);
-                    const logAttributes: Record<string, any> = {
-                        'agent.id': agentId,
-                        'cmp.id': componentId,
-                        'cmp.type': componentType,
-                        'cmp.name': componentName,
-                        'process.id': processId,
-                        'event.id': eventId,
-                        'cmp.output': result,
-                    };
+                        span.setStatus({ code: SpanStatusCode.ERROR, message: errorMessage });
+                        span.addEvent('cmp.call.error', {
+                            'event.id': eventId,
+                            'cmp.id': componentId,
+                            'cmp.type': componentType,
+                            'cmp.name': componentName,
+                            'error.type': 'result_error',
+                            'error.message': errorMessage,
+                        });
 
-                    // Only include output if formatOutputForLog returns a value
-                    // if (outputForLog !== undefined) {
-                    //     logAttributes['cmp.output'] = outputForLog;
-                    // }
+                        // Add output attributes to span
+                        span.setAttributes({
+                            'output.size': resultStr.length,
+                            'output.has_error': true,
+                        });
 
-                    const spanContext = trace.setSpan(context.active(), span);
-                    context.with(spanContext, () => {
-                        logger.emit({
-                            severityNumber: SeverityNumber.INFO,
-                            severityText: 'INFO',
-                            body: `Component ${componentType} (${componentId}) completed successfully`,
-                            attributes: logAttributes,
+                        // Emit ERROR log for result error
+                        const spanContext = trace.setSpan(context.active(), span);
+                        context.with(spanContext, () => {
+                            logger.emit({
+                                severityNumber: SeverityNumber.ERROR,
+                                severityText: 'ERROR',
+                                body: `Component ${componentType} (${componentId}) failed: ${errorMessage}`,
+                                attributes: {
+                                    'agent.id': agentId,
+                                    'process.id': processId,
+                                    'event.id': eventId,
+                                    'cmp.id': componentId,
+                                    'cmp.name': componentName,
+                                    'cmp.type': componentType,
+                                    'error.type': 'result_error',
+                                    'error.message': errorMessage,
+                                    'cmp.output': result,
+                                    'team.id': teamId,
+                                    'org.slot': orgSlot,
+                                    'org.tier': orgTier,
+                                    'source.id': sourceId,
+                                    'source.name': sourceName,
+                                    'session.id': sessionId,
+                                    'workflow.id': workflowId,
+                                    'workflow.step': workflowStep,
+                                    'log.tags': logTags,
+                                    'agent.debug': isDebugSession,
+                                    'agent.isTest': isTestDomain,
+                                },
+                            });
                         });
-                    });
+                    } else {
+                        // True success case
+                        span.setStatus({ code: SpanStatusCode.OK });
+
+                        // Add success event with output summary
+                        span.addEvent('cmp.call.result', {
+                            'output.size': resultStr.length,
+                            'output.preview': resultStr.substring(0, 200),
+                        });
+
+                        // Add output attributes to span
+                        span.setAttributes({
+                            'output.size': resultStr.length,
+                            'output.has_error': false,
+                        });
+
+                        // Emit success log with output (formatted safely)
+                        const logAttributes: Record<string, any> = {
+                            'agent.id': agentId,
+                            'cmp.id': componentId,
+                            'cmp.type': componentType,
+                            'cmp.name': componentName,
+                            'process.id': processId,
+                            'event.id': eventId,
+                            'cmp.output': result,
+                            'team.id': teamId,
+                            'org.slot': orgSlot,
+                            'org.tier': orgTier,
+                            'source.id': sourceId,
+                            'source.name': sourceName,
+                            'session.id': sessionId,
+                            'workflow.id': workflowId,
+                            'workflow.step': workflowStep,
+                            'log.tags': logTags,
+                            'agent.debug': isDebugSession,
+                            'agent.isTest': isTestDomain,
+                        };
+
+                        const spanContext = trace.setSpan(context.active(), span);
+                        context.with(spanContext, () => {
+                            logger.emit({
+                                severityNumber: SeverityNumber.INFO,
+                                severityText: 'INFO',
+                                body: `Component ${componentType} (${componentId}) completed successfully`,
+                                attributes: logAttributes,
+                            });
+                        });
+                    }
                 }
 
                 span.end();