@live-change/framework 0.9.171 → 0.9.174

package/lib/processes/commandExecutor.js

@@ -1,7 +1,24 @@
-import KeyBasedExecutionQueues from '../utils/KeyBasedExecutionQueues.js';
-import CommandQueue from '../utils/CommandQueue.js';
-import SingleEmitQueue from '../utils/SingleEmitQueue.js';
-import SplitEmitQueue from '../utils/SplitEmitQueue.js';
+import KeyBasedExecutionQueues from '../utils/KeyBasedExecutionQueues.js'
+import CommandQueue from '../utils/CommandQueue.js'
+import SingleEmitQueue from '../utils/SingleEmitQueue.js'
+import SplitEmitQueue from '../utils/SplitEmitQueue.js'
+
+import { context, propagation, trace } from '@opentelemetry/api'
+import { SpanKind } from '@opentelemetry/api'
+const tracer = trace.getTracer('live-change:commandExecutor')
+
+import { expandObjectAttributes } from '../utils.js'
+
+function spanAttributes(command, service, action) {
+  return {
+    service: service.name,
+    action_name: action.definition.name,
+    action_waitForEvents: action.definition.waitForEvents,
+    action_timeout: action.definition.timeout,
+    action_requestTimeout: action.definition.requestTimeout,
+    ...expandObjectAttributes(command, 'command'),
+  }
+}
 
 async function startCommandExecutor(service, config) {
   if(!config.runCommands) return
@@ -21,71 +38,124 @@ async function startCommandExecutor(service, config) {
           Array.isArray(queuedBy) ? (c) => JSON.stringify(queuedBy.map(k => c[k])) :
               (c) => JSON.stringify(c[queuedBy]))
       service.commandQueue.addCommandHandler(actionName, async (command) => {
-        const profileOp = await service.profileLog.begin({
-          operation: 'queueCommand', commandType: actionName,
-          commandId: command.id, client: command.client
+        if(command._trace) {
+          propagation.extract(context.active(), command._trace)
+        }
+        return tracer.startActiveSpan('queueCommand:'+command.service+'.'+command.type, {
+          root: !command._trace,
+          attributes: spanAttributes(command, service, action)
+        }, async (queueSpan) => {
+          console.log("COMMAND TRACE", command._trace)
+
+          const queueContext = context.active()
+          
+          const profileOp = await service.profileLog.begin({
+            operation: 'queueCommand', commandType: actionName,
+            commandId: command.id, client: command.client
+          })
+          
+          const routine = () => service.profileLog.profile({
+            operation: 'runCommand', commandType: actionName,
+            commandId: command.id, client: command.client
+          }, async () => {
+            return tracer.startActiveSpan('handleCommand:'+command.service+'.'+command.type, { 
+              kind: SpanKind.INTERNAL,
+              attributes: spanAttributes(command, service, action) 
+            }, queueContext, async (handleSpan) => {
+           
+              const _trace = {}
+              propagation.inject(context.active(), _trace)
+              const reportFinished = action.definition.waitForEvents ? 'command_' + command.id : undefined
+              const flags = { commandId: command.id, reportFinished, _trace }
+              const emit = (!service.app.splitEvents || this.shortEvents)
+                ? new SingleEmitQueue(service, flags)
+                : new SplitEmitQueue(service, flags)
+              
+              const result = await service.app.assertTime('command ' + action.definition.name,
+                  action.definition.timeout || 10000,
+                  async () => action.runCommand(command, (...args) => emit.emit(...args)), command)           
+
+              return tracer.startActiveSpan('handleEvents', { 
+                kind: SpanKind.INTERNAL,
+                attributes: spanAttributes(command, service, action) 
+              }, queueContext, async (handleEventsSpan) => {
+              
+                if(service.app.shortEvents) {            
+                  const bucket = {}
+                  const eventsPromise = Promise.all(emit.emittedEvents.map(event => {
+                    const handlerService = service.app.startedServices[event.service]
+                    const handler = handlerService.events[event.type]
+                    handlerService.exentQueue.queue(() => handler.execute(event, bucket))
+                  }))
+                  if (action.definition.waitForEvents) await eventsPromise
+                } else {
+                  const events = await emit.commit()            
+                  if (action.definition.waitForEvents)
+                    await service.app.waitForEvents(reportFinished, events, action.definition.waitForEvents)
+                }
+                handleEventsSpan.end()
+                handleSpan.end()
+                queueSpan.end()
+                return result
+              })
+            })
+          })
+          routine.key = keyFunction(command)
+          const promise = service.keyBasedExecutionQueues.queue(routine)
+          await service.profileLog.endPromise(profileOp, promise)
+          return promise
         })
-        const reportFinished = action.definition.waitForEvents ? 'command_' + command.id : undefined
-        const flags = { commandId: command.id, reportFinished }
-        const emit = (!service.app.splitEvents || this.shortEvents)
-          ? new SingleEmitQueue(service, flags)
-          : new SplitEmitQueue(service, flags)
-        const routine = () => service.profileLog.profile({
+      })
+    } else {
+      service.commandQueue.addCommandHandler(actionName,
+        (command) => service.profileLog.profile({
           operation: 'runCommand', commandType: actionName,
           commandId: command.id, client: command.client
         }, async () => {
-          const result = await service.app.assertTime('command ' + action.definition.name,
-              action.definition.timeout || 10000,
-              () => action.runCommand(command, (...args) => emit.emit(...args)), command)
-          if(service.app.shortEvents) {
-            const bucket = {}
-            const eventsPromise = Promise.all(emit.emittedEvents.map(event => {
-              const handlerService = service.app.startedServices[event.service]
-              const handler = handlerService.events[event.type]
-              handlerService.exentQueue.queue(() => handler.execute(event, bucket))
-            }))
-            if (action.definition.waitForEvents) await eventsPromise
-          } else {
-            const events = await emit.commit()
-            if (action.definition.waitForEvents)
-              await service.app.waitForEvents(reportFinished, events, action.definition.waitForEvents)
+          if(command._trace) {
+            propagation.extract(context.active(), command._trace)
           }
-          return result
-        })
-        routine.key = keyFunction(command)
-        const promise = service.keyBasedExecutionQueues.queue(routine)
-        await service.profileLog.endPromise(profileOp, promise)
-        return promise
-      })
-    } else {
-      service.commandQueue.addCommandHandler(actionName,
-          (command) => service.profileLog.profile({
-            operation: 'runCommand', commandType: actionName,
-            commandId: command.id, client: command.client
-          }, async () => {
+          return tracer.startActiveSpan('handleCommand:'+command.service+'.'+command.type, { 
+            kind: SpanKind.INTERNAL,
+            attributes: spanAttributes(command, service, action) 
+          }, async (handleSpan) => {
+
+            const handleContext = context.active()
+
+            const _trace = {}
+            propagation.inject(context.active(), _trace)
             const reportFinished = action.definition.waitForEvents ? 'command_' + command.id : undefined
-            const flags = {commandId: command.id, reportFinished}
+            const flags = { commandId: command.id, reportFinished, _trace }
             const emit = (!service.app.splitEvents || this.shortEvents)
               ? new SingleEmitQueue(service, flags)
               : new SplitEmitQueue(service, flags)
             const result = await service.app.assertTime('command ' + action.definition.name,
                 action.definition.timeout || 10000,
                 () => action.runCommand(command, (...args) => emit.emit(...args)), command)
-            if(service.app.shortEvents) {
-              const bucket = {}
-              const eventsPromise = Promise.all(emit.emittedEvents.map(event => {
-                const handlerService = service.app.startedServices[event.service]
-                const handler = handlerService.events[event.type]
-                handlerService.exentQueue.queue(() => handler.execute(event, bucket))
-              }))
-              if (action.definition.waitForEvents) await eventsPromise
-            } else {
-              const events = await emit.commit()
-              if (action.definition.waitForEvents)
-                await service.app.waitForEvents(reportFinished, events, action.definition.waitForEvents)
-            }
-            return result
+
+            return tracer.startActiveSpan('emitEvents', { 
+              kind: SpanKind.INTERNAL,
+              attributes: spanAttributes(command, service, action) 
+            }, handleContext, async (handleEventsSpan) => {
+              if(service.app.shortEvents) {
+                const bucket = {}
+                const eventsPromise = Promise.all(emit.emittedEvents.map(event => {
+                  const handlerService = service.app.startedServices[event.service]
+                  const handler = handlerService.events[event.type]
+                  handlerService.exentQueue.queue(() => handler.execute(event, bucket))
+                }))
+                if (action.definition.waitForEvents) await eventsPromise
+              } else {
+                const events = await emit.commit()
+                if (action.definition.waitForEvents)
+                  await service.app.waitForEvents(reportFinished, events, action.definition.waitForEvents)
+              }
+              handleEventsSpan.end()
+              handleSpan.end()
+              return result
+            })
           })
+        })
       )
 
     }

package/lib/processes/eventListener.js

@@ -3,6 +3,19 @@ import EventSourcing from '../utils/EventSourcing.js'
 import Debug from 'debug'
 const debug = Debug("framework:eventListener")
 
+import { context, propagation, trace } from '@opentelemetry/api'
+import { SpanKind } from '@opentelemetry/api'
+const tracer = trace.getTracer('live-change:eventListener')
+
+import { expandObjectAttributes } from '../utils.js'
+
+async function spanAttributes(ev, service) {
+  return {
+    ...expandObjectAttributes(ev, 'event'),
+    service: service.name
+  }
+}
+
 async function startEventListener(service, config) {
   if(!config.handleEvents) return
 
@@ -19,13 +32,25 @@ async function startEventListener(service, config) {
   for (let eventName in service.events) {
     const event = service.events[eventName]
     service.eventSourcing.addEventHandler(eventName, async (ev, bucket) => {
-      return await service.profileLog.profile({ operation: "handleEvent", eventName, id: ev.id,
-            bucketId: bucket.id, triggerId: bucket.triggerId, commandId: bucket.commandId },
-          () => {
-            debug("EXECUTING EVENT", ev)
-            return event.execute(ev, bucket)
-          }
-      )
+      if(ev._trace) {
+        propagation.extract(context.active(), ev._trace)
+      }
+      return tracer.startActiveSpan('handleEvent:'+service.name+'.'+eventName, { 
+        kind: SpanKind.INTERNAL, 
+        attributes: spanAttributes(ev, service) 
+      }, async (handleSpan) => {        
+        try {
+          return await service.profileLog.profile({ operation: "handleEvent", eventName, id: ev.id,
+              bucketId: bucket.id, triggerId: bucket.triggerId, commandId: bucket.commandId },
+            () => {
+              debug("EXECUTING EVENT", ev)
+              return event.execute(ev, bucket)
+            }
+          )
+        } finally {
+          handleSpan.end()
+        }
+      })
     })
     service.eventSourcing.onBucketEnd = async (bucket, handledEvents) => {
       if(bucket.reportFinished && handledEvents.length > 0) {

package/lib/processes/triggerExecutor.js

@@ -3,6 +3,19 @@ import CommandQueue from '../utils/CommandQueue.js'
 import SingleEmitQueue from '../utils/SingleEmitQueue.js'
 import SplitEmitQueue from '../utils/SplitEmitQueue.js'
 
+import { context, propagation, trace } from '@opentelemetry/api'
+import { SpanKind } from '@opentelemetry/api'
+const tracer = trace.getTracer('live-change:triggerExecutor')
+
+import { expandObjectAttributes } from '../utils.js'
+
+async function spanAttributes(trig, service) {
+  return {
+    ...expandObjectAttributes(trig, 'trigger'),
+    service: service.name
+  }
+}
+
 async function startTriggerExecutor(service, config) {
   if(!config.runCommands) return
 
@@ -27,7 +40,21 @@ async function startTriggerExecutor(service, config) {
     await service.dao.request(['database', 'put'], service.databaseName, 'triggerRoutes',
         { id: triggerName + '=>' + service.name, trigger: triggerName, service: service.name })
     service.triggerQueue.addCommandHandler(triggerName,
-      (trig) => Promise.all(triggers.map( trigger => trigger.execute(trig, service) ))
+      async (trig) => {
+        if(trig._trace) {
+          propagation.extract(context.active(), trig._trace)
+        }
+        return tracer.startActiveSpan('handleTriggerCall:'+service.name+'.'+triggerName, { 
+          kind: SpanKind.INTERNAL,
+          attributes: spanAttributes(trig, service)
+        }, async (triggerSpan) => {
+          try {
+            return await Promise.all(triggers.map( trigger => trigger.execute(trig, service) ))
+          } finally {
+            triggerSpan.end()
+          }
+        })
+      }
     )
   }
 

package/lib/runtime/Action.js

@@ -1,57 +1,86 @@
 import { prepareParameters, processReturn, preFilterParameters } from "./params.js"
 
+import { context, propagation, trace } from '@opentelemetry/api'
+import { loggingHelpers } from '../utils.js'
+import { SpanKind } from '@opentelemetry/api'
+const tracer = trace.getTracer('live-change:action')
+
+import { expandObjectAttributes } from '../utils.js'
+
 class Action {
 
   constructor(definition, service) {
     this.definition = definition
     this.service = service
+    this.loggingHelpers = loggingHelpers(this.service.name, this.service.app.config.clientConfig.version, {
+      action: this.definition.name,
+    })
   }
 
-  async runCommand(command, emit) {
-    let parameters = command.parameters
-    //console.log("PARAMETERS", JSON.stringify(parameters), "DEFN", this.definition.properties)
-    let preparedParams = await prepareParameters(parameters, this.definition.properties, this.service)
-    //console.log("PREP PARAMS", preparedParams)
-
-    let resultPromise = (async () => this.definition.execute({
-      ...parameters,
-      ...preparedParams
-    }, {
-      action: this,
-      service: this.service,
-      client: command.client,
-      command,
-      trigger: (trigger, data) => this.service.trigger({
-        causeType: 'action',
-        cause: command.id,
-        client: command.client,
-        ...trigger
-      }, data),
-      triggerService: (trigger, data, returnArray = false) => this.service.triggerService({
-        causeType: 'action',
-        cause: command.id,
+  async runCommand(command, emit, traceContext) {
+    return tracer.startActiveSpan('runCommand:'+this.service.name+'.'+this.definition.name, { 
+      kind: SpanKind.SERVER, 
+      attributes: {
+        ...expandObjectAttributes(command, 'command'),
+        service: this.service.name,
+        action_name: this.definition.name,
+        action_waitForEvents: this.definition.waitForEvents,
+        action_timeout: this.definition.timeout,
+        action_requestTimeout: this.definition.requestTimeout,
+      }
+    }, traceContext, async (runSpan) => {                
+
+      let parameters = command.parameters
+      //console.log("PARAMETERS", JSON.stringify(parameters), "DEFN", this.definition.properties)
+      let preparedParams = await prepareParameters(parameters, this.definition.properties, this.service)
+      //console.log("PREP PARAMS", preparedParams)
+
+      let resultPromise = (async () => this.definition.execute({
+        ...parameters,
+        ...preparedParams
+      }, {
+        action: this,
+        service: this.service,
         client: command.client,
-        ...trigger
-      }, data, returnArray)
-    }, emit))()
+        command,
+        trigger: (trigger, data) => this.service.trigger({
+          causeType: 'action',
+          cause: command.id,
+          client: command.client,
+          ...trigger
+        }, data),
+        triggerService: (trigger, data, returnArray = false) => this.service.triggerService({
+          causeType: 'action',
+          cause: command.id,
+          client: command.client,
+          ...trigger
+        }, data, returnArray),
+        ...this.loggingHelpers
+      }, emit))()
 
-    resultPromise = resultPromise.then(async result => {
-      let processedResult = await processReturn(result, this.definition.returns, this.service)
-      return processedResult
-    })
-    resultPromise.catch(error => {
-      console.error(`Action ${this.definition.name} error `, error.stack || error)
+      resultPromise = resultPromise.then(async result => {
+        let processedResult = await processReturn(result, this.definition.returns, this.service)
+        runSpan.end()
+        return processedResult
+      })
+      resultPromise.catch(error => {
+        this.loggingHelpers.error(`Action ${this.definition.name} error `, error.stack || error)
+        runSpan.end()
+      })    
+      return resultPromise
     })
-    return resultPromise
   }
 
   async callCommand(parameters, clientData) {
     // if(!clientData.roles) throw new Error("no roles") - roles are not required in frontend
+    const _trace = {}
+    propagation.inject(context.active(), _trace)
     const command = {
       type: this.definition.name,
       service: this.service.name,
       client: clientData,
-      parameters: await preFilterParameters(parameters, this.definition.properties)
+      parameters: await preFilterParameters(parameters, this.definition.properties),
+      _trace
     }
     if(parameters._commandId) command.id = parameters._commandId
     //console.log("CALL COMMAND", JSON.stringify(command, null, "  "))

package/lib/runtime/EventHandler.js

@@ -1,10 +1,15 @@
 import { prepareParameters, processReturn } from "./params.js"
+import { loggingHelpers } from '../utils.js'
 
 class EventHandler {
 
   constructor(definition, service) {
     this.definition = definition
     this.service = service
+
+    this.loggingHelpers = loggingHelpers(service.name, service.app.config.clientConfig.version, {
+      eventType: definition.name,
+    })
   }
 
   async execute(parameters, bucket) {
@@ -17,7 +22,8 @@ class EventHandler {
     }, {
       action: this,
       service: this.service,
-      bucket: bucket
+      bucket: bucket,
+      ...this.loggingHelpers
     })
 
     resultPromise = resultPromise.then(async result => {