@live-change/framework 0.9.171 → 0.9.174

package/lib/runtime/TriggerHandler.js

@@ -2,6 +2,21 @@ import { prepareParameters, processReturn } from "./params.js"
 import SplitEmitQueue from "../utils/SplitEmitQueue.js"
 import SingleEmitQueue from "../utils/SingleEmitQueue.js"
 
+import { context, propagation, trace } from '@opentelemetry/api'
+import { SpanKind } from '@opentelemetry/api'
+const tracer = trace.getTracer('live-change:triggerHandler')
+
+import { expandObjectAttributes } from '../utils.js'
+
+async function spanAttributes(trig, service) {
+  return {
+    ...expandObjectAttributes(trig, 'trigger'),
+    service: service.name
+  }
+}
+
+import { loggingHelpers } from '../utils.js'
+
 class TriggerHandler {
 
   constructor(definition, service) {
@@ -14,6 +29,10 @@ class TriggerHandler {
         Array.isArray(queuedBy) ? (c) => JSON.stringify(queuedBy.map(k=>c[k])) :
           (c) => JSON.stringify(c[queuedBy]) )
     }
+
+    this.loggingHelpers = loggingHelpers(service.name, service.app.config.clientConfig.version, {
+      triggerType: definition.name,
+    })
   }
 
   async doExecute(trig, emit) {
@@ -42,7 +61,8 @@ class TriggerHandler {
         cause: trig.id,
         client: trig.client,
         ...trigger
-      }, data, returnArray)
+      }, data, returnArray),
+      ...this.loggingHelpers
     }, emit))
     //console.log("RESULT PROMISE", resultPromise, resultPromise.then)
     resultPromise = resultPromise.then(async result => {
@@ -50,75 +70,130 @@ class TriggerHandler {
       return processedResult
     })
     resultPromise.catch(error => {
-      console.error(`Trigger ${this.definition.name} error `, error)
+      this.loggingHelpers.error(`Trigger ${this.definition.name} error `, error)
     })
     return resultPromise
   }
 
   async execute(trig, service) {
-    console.log("EXECUTE", trig, this.queueKeyFunction)
+    //console.log("EXECUTE", trig, this.queueKeyFunction)
     const profileOp = await service.profileLog.begin({
       operation: 'queueTrigger', triggerType: this.definition.name,
       triggerId: trig.id, by: trig.by
     })
     if(this.queueKeyFunction) {
-      console.log("QUEUED TRIGGER STARTED", trig)
-      const routine = () => service.profileLog.profile({
-        operation: 'runTrigger', triggerType: this.definition.name,
-        commandId: trig.id, by: trig.by
-      }, async () => {
-        let result
-        const reportFinished = this.definition.waitForEvents ? 'trigger_' + trig.id : undefined
-        const flags = {triggerId: trig.id, reportFinished}
-        const emit = service.app.splitEvents
-          ? new SplitEmitQueue(service, flags)
-          : new SingleEmitQueue(service, flags)
+      //console.log("QUEUED TRIGGER STARTED", trig)
+      return tracer.startActiveSpan('queueTrigger:'+service.name+'.'+this.definition.name, { 
+        kind: SpanKind.INTERNAL, 
+        attributes: spanAttributes(trig, service) 
+      }, async (queueSpan) => {      
+        const queueContext = context.active()
+
+        const routine = () => service.profileLog.profile({
+          operation: 'runTrigger', triggerType: this.definition.name,
+          commandId: trig.id, by: trig.by
+        }, async () => {
+          return tracer.startActiveSpan('handleTrigger:'+service.name+'.'+this.definition.name, { 
+            kind: SpanKind.INTERNAL, 
+            attributes: spanAttributes(trig, service) 
+          }, queueContext, async (handleSpan) => {        
+            let result
+            const reportFinished = this.definition.waitForEvents ? 'trigger_' + trig.id : undefined
+            const _trace = {}
+            propagation.inject(context.active(), _trace)
+            const flags = {triggerId: trig.id, reportFinished, _trace }
+            const emit = service.app.splitEvents
+              ? new SplitEmitQueue(service, flags)
+              : new SingleEmitQueue(service, flags)
+
+            await tracer.startActiveSpan('runTrigger', { 
+              kind: SpanKind.SERVER, 
+              attributes: spanAttributes(trig, service) 
+            }, queueContext, async (runSpan) => {              
+              try {
+                //console.log("TRIGGER RUNNING!", trig)         
+
+                result = await service.app.assertTime('trigger ' + this.definition.name,
+                  this.definition.timeout || 10000,
+                  () => this.doExecute(trig, (...args) => emit.emit(...args)))          
+              } catch (e) {
+                this.loggingHelpers.error(`Trigger ${this.definition.name} error `, e.stack)
+                runSpan.end()
+                handleSpan.end()
+                queueSpan.end()
+                throw e
+              }
+              runSpan.end()
+              return result
+            })                    
+            return await tracer.startActiveSpan('emitEvents', {
+              kind: SpanKind.INTERNAL, 
+              attributes: spanAttributes(trig, service) 
+            }, queueContext, async (emitEventsSpan) => {              
+              const events = await emit.commit()
+              if (this.definition.waitForEvents)
+                await service.app.waitForEvents(reportFinished, events, this.definition.waitForEvents)
+              emitEventsSpan.end()
+              handleSpan.end()
+              queueSpan.end()
+              return result
+            })
+          })
+        })
         try {
-          console.log("TRIGGER RUNNING!", trig)
-          result = await service.app.assertTime('trigger ' + this.definition.name,
-            this.definition.timeout || 10000,
-            () => this.doExecute(trig, (...args) => emit.emit(...args)))
-          console.log("TRIGGER DONE!", trig)
+          routine.key = this.queueKeyFunction(trig)
         } catch (e) {
-          console.error(`TRIGGER ${this.definition.name} ERROR`, e.stack)
-          throw e
+          this.loggingHelpers.error("Queue key function error ", e)
         }
-        const events = await emit.commit()
-        if (this.definition.waitForEvents)
-          await service.app.waitForEvents(reportFinished, events, this.definition.waitForEvents)
-        return result
+        this.loggingHelpers.log("Trigger queue key", routine.key)
+        const promise = service.keyBasedExecutionQueues.queue(routine)
+        await service.profileLog.endPromise(profileOp, promise)
+        return promise
       })
-      try {
-        routine.key = this.queueKeyFunction(trig)
-      } catch (e) {
-        console.error("QUEUE KEY FUNCTION ERROR", e)
-      }
-      console.log("TRIGGER QUEUE KEY", routine.key)
-      const promise = service.keyBasedExecutionQueues.queue(routine)
-      await service.profileLog.endPromise(profileOp, promise)
-      return promise
     } else {
-      console.log("NOT QUEUED TRIGGER STARTED", trig)
-      const reportFinished = this.definition.waitForEvents ? 'trigger_'+trig.id : undefined
-      const flags = { triggerId: trig.id, reportFinished }
-      const emit = service.app.splitEvents
-        ? new SplitEmitQueue(service, flags)
-        : new SingleEmitQueue(service, flags)
-      let result
-      try {
-        result = await service.app.assertTime('trigger '+this.definition.name,
-          this.definition.timeout || 10000,
-          () => this.doExecute(trig, (...args) => emit.emit(...args)))
-        console.log("TRIGGER DONE!", trig)
-      } catch (e) {
-        console.error(`TRIGGER ${this.definition.name} ERROR`, e.stack)
-        throw e
-      }
-      const events = await emit.commit()
-      if(this.definition.waitForEvents)
-        await service.app.waitForEvents(reportFinished, events, this.definition.waitForEvents)
-      await service.profileLog.end(profileOp)
-      return result
+      return tracer.startActiveSpan('handleTrigger:'+service.name+'.'+this.definition.name, { 
+        kind: SpanKind.INTERNAL, 
+        attributes: spanAttributes(trig, service) 
+      }, async (handleSpan) => {      
+        this.loggingHelpers.log("Not queued trigger started", trig)
+        const reportFinished = this.definition.waitForEvents ? 'trigger_'+trig.id : undefined      
+        const _trace = {}
+        propagation.inject(context.active(), _trace)
+        const flags = { triggerId: trig.id, reportFinished, _trace }
+        const emit = service.app.splitEvents
+          ? new SplitEmitQueue(service, flags)
+          : new SingleEmitQueue(service, flags)
+        let result        
+        await tracer.startActiveSpan('runTrigger:'+service.name+'.'+this.definition.name, { 
+          kind: SpanKind.SERVER, 
+          attributes: spanAttributes(trig, service) 
+        }, async (runSpan) => {
+          try {          
+            result = await service.app.assertTime('trigger '+this.definition.name,
+              this.definition.timeout || 10000,
+              () => this.doExecute(trig, (...args) => emit.emit(...args)))
+            runSpan.end()
+            this.loggingHelpers.log("Trigger done", trig)
+          } catch (e) {
+            this.loggingHelpers.error(`Trigger ${this.definition.name} error `, e.stack)
+            runSpan.end()
+            handleSpan.end()
+            throw e
+          }
+        })
+        return tracer.startActiveSpan('emitEvents', { 
+          kind: SpanKind.INTERNAL, 
+          attributes: spanAttributes(trig, service) 
+        }, async (emitEventsSpan) => {          
+          const events = await emit.commit()      
+          if(this.definition.waitForEvents)
+            await service.app.waitForEvents(reportFinished, events, this.definition.waitForEvents)
+          emitEventsSpan.end()
+          handleSpan.end()
+          await service.profileLog.end(profileOp)
+          return result
+        })
+      })
     }
   }
 

package/lib/utils.js

@@ -365,4 +365,63 @@ export function parseDuration(duration) {
     result += value * { s: 1000, m: 60000, h: 3600000, d: 86400000 }[unit]
   }
   return result
+}
+
+import { logs, SeverityNumber } from '@opentelemetry/api-logs'
+import { context } from '@opentelemetry/api'
+
+export function loggingHelper(logger, severityNumber, severityText, attributes) {
+  return (message, ...args) => {  
+    logger.emit({
+      severityNumber, severityText,
+      body: [message, ...args].map(a => {
+        try {
+          return JSON.stringify(a)
+        } catch (e) {
+          return `${a}`
+        }
+      }).join(' '),
+      attributes: {
+        ...attributes,
+        'log.type': 'LogRecord',
+        message,        
+        logArgs: args.map(a => {
+          try {
+            return JSON.stringify(a)
+          } catch (e) {
+            return `${a}`
+          }
+        }),
+      },
+      context: context.active()
+    })
+  }
+}
+
+export function loggingHelpers(name, version, attributes, options) {
+  const logger = logs.getLogger(name, version, options)
+  return {
+    log: loggingHelper(logger, SeverityNumber.INFO, 'INFO', attributes),
+    warn: loggingHelper(logger, SeverityNumber.WARN, 'WARN', attributes),
+    error: loggingHelper(logger, SeverityNumber.ERROR, 'ERROR', attributes),
+    debug: loggingHelper(logger, SeverityNumber.DEBUG, 'DEBUG', attributes),
+    trace: loggingHelper(logger, SeverityNumber.TRACE, 'TRACE', attributes),
+    fatal: loggingHelper(logger, SeverityNumber.FATAL, 'FATAL', attributes),    
+  }
+}
+
+export function expandObjectAttributes(object, prefix = '', acc = {}) {
+  if(typeof object !== 'object') {
+    acc[prefix] = object
+    return
+  }
+  if(object === null || object === undefined) {
+    acc[prefix] = object
+    return
+  }
+  //if(Array.isArray(object)) return object.map(item => expandObjectAttributes(item, prefix))
+  for(const [key, value] of Object.entries(object)) {
+    expandObjectAttributes(value, prefix + '_' + key, acc)
+  }
+  return acc
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/framework",
-  "version": "0.9.171",
+  "version": "0.9.174",
   "description": "Live Change Framework - ultimate solution for real time mobile/web apps",
   "main": "index.js",
   "scripts": {
@@ -22,11 +22,11 @@
   },
   "homepage": "https://github.com/live-change/live-change-stack",
   "devDependencies": {
-    "@live-change/dao": "^0.9.171",
-    "@live-change/uid": "^0.9.171",
+    "@live-change/dao": "^0.9.174",
+    "@live-change/uid": "^0.9.174",
     "typedoc": "0.28.3",
     "typedoc-plugin-markdown": "^4.6.3",
     "typedoc-plugin-rename-defaults": "^0.7.3"
   },
-  "gitHead": "2a684f9d6b097ef5b8e1e08edb4995949ee33330"
+  "gitHead": "6ebdadad702526df240bd3aa7ac3d97324a0308a"
 }

package/tsconfig.json

@@ -20,11 +20,12 @@
     "esModuleInterop": true,    // Enable interop for ES modules
     "resolveJsonModule": true,  // Allow importing JSON files
     "skipLibCheck": true,
-    "noImplicitAny": false
+    "noImplicitAny": false,
+    "types": []
   },
   "files": ["index.ts"],
   "include": [
     "lib/**/*.ts", "lib/**/*.js", "index.ts"],
-  "exclude": ["node_modules/@types", "node_modules/**/*.d.ts", "**/*.test.js", "**/CMakeFiles/**"]
+  "exclude": ["node_modules/@types", "node_modules/**/*.d.ts", "**/*.test.js", "**/CMakeFiles/**", "**/node_modules/@hapi/**"]
 }