feat: adding event logging to EdgeWorker SDK

Author: jonathannorris

sdk/edge-worker-server/src/client.ts

@@ -20,8 +20,10 @@ import {
     UserError,
     DevCycleEvent,
     checkParamDefined,
+    EventTypes,
 } from '@devcycle/server-request'
 import { generateBucketedConfig } from '@devcycle/bucketing'
+import { generateAggEvent, publishDevCycleEvents } from './eventsPublisher'
 
 const castIncomingUser = (user: DevCycleUser) => {
     if (!(user instanceof DevCycleUser)) {
@@ -31,6 +33,7 @@ const castIncomingUser = (user: DevCycleUser) => {
 }
 
 export class DevCycleEdgeClient {
+    private sdkKey: string
     private options: DevCycleCloudOptions
     private configHelper: EnvironmentConfigManager
     private onInitialized: Promise<DevCycleEdgeClient>
@@ -39,6 +42,7 @@ export class DevCycleEdgeClient {
     private configData: ConfigBody
 
     constructor(sdkKey: string, options: DevCycleCloudOptions = {}) {
+        this.sdkKey = sdkKey
         this.options = options
         this.logger =
             options?.logger || dvcDefaultLogger({ level: options?.logLevel })
@@ -71,10 +75,6 @@ export class DevCycleEdgeClient {
                 }
                 return this
             })
-
-        // process.on('exit', () => {
-        //     this.close()
-        // })
     }
 
     setConfigData(sdkKey: string, projectConfigStr: string): void {
@@ -139,7 +139,26 @@ export class DevCycleEdgeClient {
             }
         }
 
-        return new DVCVariable(options)
+        const dvcVariable = new DVCVariable(options)
+
+        const aggEvents = generateAggEvent(
+            populatedUser.user_id,
+            dvcVariable.isDefaulted
+                ? EventTypes.aggVariableDefaulted
+                : EventTypes.aggVariableEvaluated,
+            key,
+            bucketedConfig.variableVariationMap,
+        )
+        // Don't await for the event to be published to the Events API
+        publishDevCycleEvents(
+            this.logger,
+            this.sdkKey,
+            populatedUser,
+            aggEvents,
+            bucketedConfig.featureVariationMap,
+        )
+
+        return dvcVariable
     }
 
     async variableValue<T extends DVCVariableValue>(
@@ -180,7 +199,10 @@ export class DevCycleEdgeClient {
         return bucketedConfig?.features || {}
     }
 
-    async track(user: DevCycleUser, event: DevCycleEvent): Promise<void> {
+    async track(
+        user: DevCycleUser,
+        event: DevCycleEvent | DevCycleEvent[],
+    ): Promise<void> {
         const incomingUser = castIncomingUser(user)
 
         if (!this.initialized) {
@@ -195,17 +217,22 @@ export class DevCycleEdgeClient {
             incomingUser,
             this.options,
         )
-        // this.eventQueue.queueEvent(populatedUser, event)
-    }
+        const bucketedConfig = generateBucketedConfig({
+            config: this.configData,
+            user: populatedUser,
+        })
 
-    async flushEvents(callback?: () => void): Promise<void> {
-        // return this.eventQueue.flushEvents().then(callback)
+        await publishDevCycleEvents(
+            this.logger,
+            this.sdkKey,
+            populatedUser,
+            typeof event === 'object' ? [event] : event,
+            bucketedConfig.featureVariationMap,
+        )
     }
 
     async close(): Promise<void> {
         await this.onInitialized
-        await this.flushEvents()
         this.configHelper.cleanup()
-        // this.eventQueue.cleanup()
     }
 }

sdk/edge-worker-server/src/eventsPublisher.ts

@@ -0,0 +1,53 @@
+import { DVCPopulatedUser } from '@devcycle/js-cloud-server-sdk'
+import {
+    DevCycleEvent,
+    DVCRequestEvent,
+    publishEvents,
+} from '@devcycle/server-request'
+import { BucketedUserConfig, DVCLogger, SDKEventBatchRequestBody } from '@devcycle/types'
+
+export function generateAggEvent(
+    user_id: string,
+    type: string,
+    variableKey: string,
+    variableVariationMap: BucketedUserConfig['variableVariationMap'],
+): DVCRequestEvent[] {
+    return new DVCRequestEvent({
+        type,
+        target: variableKey,
+        value: 1,
+        metaData: variableVariationMap[variableKey]
+    }, user_id)
+}
+
+export async function publishDevCycleEvents(
+    logger: DVCLogger,
+    sdkKey: string,
+    user: DVCPopulatedUser,
+    events: DevCycleEvent[],
+    featureVars: Record<string, string>,
+): Promise<void> {
+    const requestEvents = events.map((event) => {
+        return new DVCRequestEvent(event, user.user_id, featureVars)
+    })
+    const requestBody: SDKEventBatchRequestBody = [
+        {
+            user,
+            events: requestEvents,
+        },
+    ]
+    try {
+        const res = await publishEvents(logger, sdkKey, requestBody)
+        if (res.status !== 201) {
+            this.logger.error(
+                `Error publishing events, status: ${
+                    res.status
+                }, body: ${await res.text()}`,
+            )
+        } else {
+            this.logger.debug(
+                `DevCycle Flushed ${requestEvents.length} Events`,
+            )
+        }
+    }
+}

sdk/nodejs/src/eventQueue.ts

@@ -122,7 +122,7 @@ export class EventQueue {
                 metricTags,
             )
         } catch (ex) {
-            this.logger.error(`DVC Error Flushing Events: ${ex.message}`)
+            this.logger.error(`DevCycle Error Flushing Events: ${ex.message}`)
         }
 
         const results: FlushResults = {
@@ -149,7 +149,7 @@ export class EventQueue {
             val + batches.eventCount
         const eventCount = flushPayloads.reduce(reducer, 0)
         this.logger.debug(
-            `DVC Flush ${eventCount} Events, for ${flushPayloads.length} Users`,
+            `DevCycle Flush ${eventCount} Events, for ${flushPayloads.length} Users`,
         )
 
         const startTimeRequests = Date.now()
@@ -186,7 +186,7 @@ export class EventQueue {
                         }
                     } else {
                         this.logger.debug(
-                            `DVC Flushed ${eventCount} Events, for ${flushPayload.records.length} Users`,
+                            `DevCycle Flushed ${eventCount} Events, for ${flushPayload.records.length} Users`,
                         )
                         getBucketingLib().onPayloadSuccess(
                             this.sdkKey,
@@ -196,7 +196,7 @@ export class EventQueue {
                     }
                 } catch (ex) {
                     this.logger.error(
-                        `DVC Error Flushing Events response message: ${ex.message}`,
+                        `DevCycle Error Flushing Events response message: ${ex.message}`,
                     )
                     getBucketingLib().onPayloadFailure(
                         this.sdkKey,
@@ -240,7 +240,7 @@ export class EventQueue {
         try {
             await this._flushEvents()
         } catch (e) {
-            this.logger.error(`DVC Error Flushing Events`, e)
+            this.logger.error(`DevCycle Error Flushing Events`, e)
         }
 
         this.flushInProgress = false