[#398] Support Exception Chain Metadata (PExceptionMetaData)

Author: feelform

lib/client/data-sender.js

@@ -51,6 +51,8 @@ class DataSender {
       this.dataSender.sendSqlMetaInfo(data)
     } else if (data instanceof SqlUidMetaData) {
       this.dataSender.sendSqlUidMetaData(data)
+    } else if (data?.isExceptionMetaData?.()) {
+      this.dataSender.sendExceptionMetaData(data)
     }
   }
 

lib/client/grpc-data-sender.js

@@ -235,6 +235,14 @@ class GrpcDataSender {
     })
   }
 
+  sendExceptionMetaData(exceptionMetaData) {
+    const pExceptionMetaData = exceptionMetaData.valueOfProtocolBuffer()
+    const options = this.unaryDeadlineOptionsBuilder.build()
+    this.metadataClient.requestExceptionMetaData(pExceptionMetaData, options, (err) => {
+      logError(err)
+    })
+  }
+
   sendSpan(span) {
     try {
       const pSpan = span.toProtocolBuffer()

lib/context/trace/exception-builder.js

@@ -11,6 +11,7 @@ const { namedGroupCallSite } = require('../../instrumentation/call-stack')
 const { LongAnnotation } = require('../../instrumentation/context/annotation/long-annotation')
 const AnnotationKey = require('../annotation-key')
 const exceptionChainIdAnnotationKey = new AnnotationKey(-52, 'ExceptionChainId')
+const spanMessages = require('../../data/v1/Span_pb')
 
 class Frame {
     constructor(className = '', fileName = 'unknown', lineNumber = 0, methodName = '') {
@@ -19,6 +20,15 @@ class Frame {
         this.lineNumber = lineNumber
         this.methodName = methodName
     }
+
+    toProtocolBuffer() {
+        const pFrame = new spanMessages.PFrame()
+        pFrame.setClassname(this.className)
+        pFrame.setFilename(this.fileName)
+        pFrame.setLinenumber(this.lineNumber)
+        pFrame.setMethodname(this.methodName)
+        return pFrame
+    }
 }
 
 class Exception {
@@ -36,7 +46,17 @@ class Exception {
     }
 
     toProtocolBuffer() {
-
+        const pException = new spanMessages.PException()
+        pException.setExceptiontype(exception.type)
+        pException.setExceptionmessage(exception.message)
+        pException.setStarttime(exception.startTime)
+        pException.setExceptionid(exception.exceptionId)
+        pException.setExceptiondepth(exception.exceptionDepth)
+
+        this.frameStack.forEach(frame => {
+            pException.addStacktraceelement(frame.toProtocolBuffer())
+        })
+        return pException
     }
 }
 

lib/context/trace/exception-meta-data-builder.js

@@ -0,0 +1,59 @@
+/**
+ * Pinpoint Node.js Agent
+ * Copyright 2020-present NAVER Corp.
+ * Apache License v2.0
+ */
+
+'use strict'
+const spanMessages = require('../../data/v1/Span_pb')
+
+class ExceptionMetaData {
+    constructor(traceRoot, exceptions, uriTemplate) {
+        this.traceRoot = traceRoot
+        this.exceptions = exceptions
+        this.uriTemplate = uriTemplate
+    }
+
+    isExceptionMetaData() {
+        return true
+    }
+
+    valueOfProtocolBuffer() {
+        const pExceptionMetaData = new spanMessages.pExceptionMetaData()
+        pExceptionMetaData.setTransactionid(this.traceRoot.getTraceId().toProtocolBuffer())
+        pExceptionMetaData.setSpanid(this.traceRoot.getTraceId().getSpanId())
+        pExceptionMetaData.setUriTemplate(this.uriTemplate)
+
+        const pExceptions = this.exceptions.map(exception => {
+            return exception.toProtocolBuffer()
+        })
+        pExceptionMetaData.setExceptionsList(pExceptions)
+    }
+}
+
+class ExceptionMetaDataBuilder {
+    constructor(traceRoot) {
+        this.traceRoot = traceRoot
+        this.exceptions = []
+        this.uriTemplate = 'NULL'
+    }
+
+    setUriTemplate(uriTemplate) {
+        this.uriTemplate = uriTemplate
+        return this
+    }
+
+    addException(exception) {
+        this.exceptions.push(exception)
+        return this
+    }
+
+    build() {
+        return new ExceptionMetaData(this.traceRoot, this.exceptions, this.uriTemplate)
+    }
+}
+
+module.exports = {
+    ExceptionMetaData,
+    ExceptionMetaDataBuilder
+}

lib/context/trace/exceptions-builder.js

@@ -7,7 +7,7 @@
 'use strict'
 
 const SpanEventBuilder = require('./span-event-builder')
-const { ExceptionsBuilder } = require('./exceptions-builder')
+const { ExceptionMetaDataBuilder } = require('./exception-meta-data-builder')
 
 // bufferSize in DefaultContextConfig.java
 const bufferSize = 20
@@ -18,7 +18,6 @@ class SpanRepository {
         this.dataSender = dataSender
         this.buffer = []
         this.agentInfo = agentInfo
-        this.exceptionsBuilder = null
         this.exceptions = []
     }
 
@@ -58,39 +57,43 @@ class SpanRepository {
         this.dataSender.send(this.spanChunkBuilder.build(spanEvents))
     }
 
+    filterExceptions(spanEvents) {
+        if (!Array.isArray(spanEvents) || spanEvents.length === 0) {
+            return []
+        }
+
+        const exceptions = spanEvents
+            .map(spanEvent => spanEvent?.exception)
+            .filter(Boolean)
+
+        if (exceptions.length === 0) {
+            return []
+        }
+
+        return exceptions
+    }
+
     storeSpan(spanBuilder) {
         if (!spanBuilder) {
             return
         }
         // GrpcSpanProcessorV2.java: postProcess(Span span, pSpan)
         const sortedSpanEventBuilders = calculateStartElapsedTime(this.bufferDrain(), spanBuilder.getStartTime())
         const spanEvents = sortedSpanEventBuilders.map(builder => builder.build())
-        this.exceptions = this.exceptions.concat(this.filterExceptions(spanEvents))
         spanBuilder.setSpanEventList(spanEvents)
         spanBuilder.setApplicationServiceType(this.agentInfo.getApplicationServiceType())
         this.dataSender.send(spanBuilder.build())
+
+        const exceptions = this.exceptions.concat(this.filterExceptions(spanEvents))
+        const builder = new ExceptionMetaDataBuilder(spanBuilder.getTraceRoot())
+        exceptions.forEach(exception => builder.addException(exception))
+        this.dataSender.send(builder.build())
     }
 
     flush() {
         const buffer = this.bufferDrain()
         this.sendSpanChunk(buffer)
     }
-
-    filterExceptions(spanEvents) {
-        if (!Array.isArray(spanEvents) || spanEvents.length === 0) {
-            return []
-        }
-
-        const exceptions = spanEvents
-            .map(spanEvent => spanEvent?.exception)
-            .filter(Boolean)
-
-        if (exceptions.length === 0) {
-            return []
-        }
-
-        return exceptions
-    }
 }
 
 module.exports = SpanRepository