[#229] Support TraceRoot

*  Refactoring Trace, AsyncTrace, DisableTrace and AsyncDisableTrace With TraceRoot
* continueTrace parent Information header parsing
* implements TraceId

lib/config.js

@@ -10,8 +10,6 @@ const path = require('path')
 const fs = require('fs')
 const defaultConfig = require('./pinpoint-config-default')
 const log = require('./utils/logger')
-const { setLog } = require('./supports')
-const { makeLogLevelLog } = require('./utils/log/log-level-logger')
 const ServiceConfigBuilder = require('./client/retry/service-config-builder')
 
 const valueOfString = (envName) => {
@@ -147,7 +145,6 @@ const init = (initOptions = {}) => {
     readConfigJson(initOptions))
 
   log.init(agentConfig.logLevel)
-  setLog(makeLogLevelLog(agentConfig.logLevel))
 
   Object.entries(REQUIRE_CONFIG).forEach(([propertyName, description]) => {
     if (agentConfig.enable && !agentConfig[propertyName]) {

lib/context/async-id.js

@@ -13,6 +13,11 @@ class AsyncId {
   static asyncIdGenerator = new SequenceGenerator(1)
   static nonAsyncId = new AsyncId(0, 0)
 
+  // DefaultAsyncIdGenerator.java: nextAsyncId()
+  static make() {
+    return new AsyncId(AsyncId.asyncIdGenerator.next, 0)
+  }
+
   constructor(asyncId, sequence) {
     this.asyncId = asyncId
     this.sequence = sequence
@@ -31,6 +36,11 @@ class AsyncId {
     return new AsyncId(asyncId, this.sequence + 1)
   }
 
+  // DefaultAsyncId.java: nextLocalAsyncId
+  nextLocalAsyncId2() {
+    return new AsyncId(this.asyncId, this.sequence + 1)
+  }
+
   sequenceNextLocalAsyncId() {
     if (this === AsyncId.nonAsyncId) {
       return this.nextLocalAsyncId() 

lib/context/disable-span-recorder.js

@@ -24,8 +24,6 @@ class DisableSpanRecorder {
     recordRemoteAddr() {}
 
     recordException() {}
-
-    recordSpanEvent() {}
 }
 
 module.exports = DisableSpanRecorder

lib/context/disable-trace.js

@@ -16,6 +16,10 @@ class DisableTrace {
         this.spanRecorder = new DisableSpanRecorder()
     }
 
+    getTraceRoot() {
+        return this.traceRoot
+    }
+
     traceBlockBegin() {
         return new DisableSpanEventRecorder()
     }

lib/context/remote-trace-root-builder.js

@@ -6,8 +6,8 @@
 
 'use strict'
 
-const TraceRootBuilder = require("./trace-root-builder")
-const TraceIdBuilder = require("./trace/trace-id-builder")
+const TraceRootBuilder = require('./trace-root-builder')
+const TraceIdBuilder = require('./trace/trace-id-builder')
 
 class RemoteTraceRoot {
     constructor(traceId, traceRoot) {
@@ -18,6 +18,10 @@ class RemoteTraceRoot {
     getTraceStartTime() {
         return this.traceRoot.getTraceStartTime()
     }
+
+    isSampled() {
+        return true
+    }
 }
 
 class RemoteTraceRootBuilder {

lib/context/sequence-generator.js

@@ -24,6 +24,13 @@ class SequenceGenerator {
     return this.next.toString()
   }
 
+  getAndIncrement() {
+    if (this.sequence > this.maxValue) {
+      this.sequence = this.initValue
+    }
+    return this.sequence++
+  }
+
   // for test
   reset() {
     this.sequence = this.initValue

lib/context/span-builder.js

@@ -9,17 +9,74 @@
 class Span {
     constructor(traceRoot) {
         this.traceRoot = traceRoot
-        this.startTime = traceRoot.getTraceStartTime()
     }
 }
 
 class SpanBuilder {
     constructor(traceRoot) {
         this.traceRoot = traceRoot
+        this.annotations = []
+        this.startTime = traceRoot.getTraceStartTime()
+    }
+
+    setApiId(apiId) {
+        this.apiId = apiId
+        return this
+    }
+
+    setRpc(rpc) {
+        this.rpc = rpc
+        return this
+    }
+
+    setEndPoint(endPoint) {
+        this.endPoint = endPoint
+        return this
+    }
+
+    setRemoteAddress(remoteAddress) {
+        this.remoteAddress = remoteAddress
+        return this
+    }
+
+    addAnnotation(annotation) {
+        this.annotations.push(annotation)
+        return this
+    }
+
+    setExceptionInfo(id, message) {
+        this.exceptionInfo = { id, message }
+        return this
+    }
+
+    setAcceptorHost(acceptorHost) {
+        this.acceptorHost = acceptorHost
+        return this
+    }
+
+    setParentApplicationName(parentApplicationName) {
+        this.parentApplicationName = parentApplicationName
+        return this
+    }
+
+    setParentApplicationType(parentApplicationType) {
+        this.parentApplicationType = parentApplicationType
+        return this
     }
 
     build() {
-        return new Span(this.traceRoot)
+        const span = new Span(this.traceRoot)
+        this.startTime = this.startTime || Date.now()
+        span.apiId = this.apiId
+        span.rpc = this.rpc
+        span.endPoint = this.endPoint
+        span.remoteAddress = this.remoteAddress
+        span.annotations = this.annotations
+        span.exceptionInfo = this.exceptionInfo
+        span.acceptorHost = this.acceptorHost
+        span.parentApplicationName = this.parentApplicationName
+        span.parentApplicationType = this.parentApplicationType
+        return span
     }
 }
 

lib/context/span-chunk-builder.js

@@ -5,12 +5,8 @@
  */
 
 'use strict'
-class SpanChunk {
-    constructor(traceRoot, spanEventList) {
-        this.traceRoot = traceRoot
-        this.spanEventList = spanEventList
-    }
-}
+
+const SpanChunk = require('./trace/span-chunk2')
 
 class SpanChunkBuilder {
     constructor(traceRoot) {

lib/context/span-id.js

@@ -8,6 +8,8 @@
 
 // SpanId.java in Java agent
 class SpanId {
+  static nullSpanId = -1
+
   constructor () {
     this.MAX_NUM = Number.MAX_SAFE_INTEGER
   }

lib/context/span-recorder.js

@@ -77,12 +77,6 @@ class SpanRecorder {
       this.span.err = 1
     }
   }
-
-  recordSpanEvent(spanEvent) {
-    if (this.span && spanEvent) {
-      this.span.spanEventList.push(spanEvent)
-    }
-  }
 }
 
 module.exports = SpanRecorder

lib/context/trace-context.js

@@ -14,16 +14,12 @@ const log = require('../utils/logger')
 const sampler = require('../sampler/sampler')
 const DisableTrace = require('./disable-trace')
 const localStorage = require('../instrumentation/context/local-storage')
-const TraceRootBuilder = require('./trace-root-builder')
-const RemoteTraceRootBuilder = require('./remote-trace-root-builder')
 const activeRequestRepository = require('./trace/active-request-repository')
 const TraceSampler = require('./trace/trace-sampler')
 const SpanBuilder = require('./span-builder')
 const SpanChunkBuilder = require('./span-chunk-builder')
 const SpanRepository = require('./trace/span-repository')
-const SpanRecorder = require('./span-recorder')
-const SpanEventRecorderBuilder = require('./trace/span-event-recorder-builder')
-const TraceBuilder = require('./trace-builder')
+const Trace2 = require('./trace/trace2')
 
 class TraceContext {
   constructor(agentInfo, dataSender, config) {
@@ -34,8 +30,7 @@ class TraceContext {
       this.isSampling = sampler.getIsSampling(config.sampling, config.sampleRate)
       this.enableSampling = config.sampling
     }
-    this.traceSampler = new TraceSampler(config)
-    this.localTraceRootBuilder = new TraceRootBuilder(agentInfo.agentId)
+    this.traceSampler = new TraceSampler(agentInfo, config)
   }
 
   continueTraceObject(requestData) {
@@ -111,31 +106,33 @@ class TraceContext {
 
   // disableSampling() method in DefaultBaseTraceFactory.java
   disableSampling() {
-    const state = this.traceSampler.getContinueDisabledState()
-    return this.newLocalTrace(state.nextId())
+    const traceRoot = this.traceSampler.makeContinueDisableTraceRoot()
+    return this.newLocalTrace(traceRoot)
   }
 
-  newLocalTrace(nextDisabledId) {
-    const traceRoot = this.localTraceRootBuilder.build(nextDisabledId)
+  newLocalTrace(traceRoot) {
     activeRequestRepository.registry(traceRoot)
     return new DisableTrace(traceRoot)
   }
 
   // newTraceObject method in DefaultBaseTraceFactory.java
   newTraceObject2(urlPath) {
-    const state = this.traceSampler.newState(urlPath)
-    if (!state.isSampled()) {
-      return this.newLocalTrace(state.nextId())
+    const traceRoot = this.traceSampler.makeNewTraceRoot(urlPath)
+    if (!traceRoot.isSampled()) {
+      return this.newLocalTrace(traceRoot)
     }
 
-    const traceRoot = new RemoteTraceRootBuilder(this.agentInfo).build(state.nextId())
-    const span = new SpanBuilder(traceRoot).build()
+    const spanBuilder = new SpanBuilder(traceRoot)
     const spanChunkBuilder = new SpanChunkBuilder(traceRoot)
     const repository = new SpanRepository(spanChunkBuilder, this.dataSender)
+    return new Trace2(spanBuilder, repository, this.agentInfo.getServiceType())
+  }
 
-    const spanRecorder = new SpanRecorder(span)
-    const spanEventRecorder = new SpanEventRecorderBuilder(traceRoot).build()
-    return new TraceBuilder(span, repository, spanRecorder, spanEventRecorder).build()
+  // DefaultAsyncContext.java: newAsyncContextTrace
+  // DefaultBaseTraceFactory.java: continueAsyncContextTraceObject
+  continueAsyncContextTraceObject(traceRoot, asyncId) {
+    const localAsyncId = asyncId.nextLocalAsyncId2()
+
   }
 }
 

lib/context/trace-root-builder.js

@@ -16,6 +16,10 @@ class TraceRoot {
     getTraceStartTime() {
         return this.traceStartTime
     }
+
+    isSampled() {
+        return false
+    }
 }
 
 class TraceRootBuilder {

lib/context/trace/async-span-chunk-builder.js

@@ -0,0 +1,43 @@
+/**
+ * Pinpoint Node.js Agent
+ * Copyright 2020-present NAVER Corp.
+ * Apache License v2.0
+ */
+
+'use strict'
+
+const SpanChunk = require('./span-chunk2')
+
+// DefaultAsyncSpanChunk.java
+class AsyncSpanChunk extends SpanChunk {
+    constructor(traceRoot, spanEventList, localAsyncId) {
+        super(traceRoot, spanEventList)
+        this.localAsyncId = localAsyncId
+    }
+
+    getLocalAsyncId() {
+        return this.localAsyncId
+    }
+
+    toString() {
+        return `AsyncSpanChunk(traceRoot=${this.traceRoot}, spanEventList=${this.spanEventList}, localAsyncId=${this.localAsyncId})`
+    }
+}
+
+// AsyncSpanChunkFactory.java
+class AsyncSpanChunkBuilder {
+    constructor(traceRoot, localAsyncId) {
+        this.traceRoot = traceRoot
+        this.localAsyncId = localAsyncId
+    }
+
+    build(spanEventList) {
+        return new AsyncSpanChunk(this.traceRoot, this.asyncId, spanEventList)
+    }
+
+    toString() {
+        return `AsyncSpanChunkBuilder(traceRoot=${this.traceRoot}, localAsyncId=${this.localAsyncId})`
+    }
+}
+
+module.exports = AsyncSpanChunkBuilder