channels-1094

README.md

@@ -531,7 +531,7 @@ The `perform` method accepts two arguments, (1) the request client instance (ext
 - `features` - The features available in the request based on the customer's sourceID. Features can only be enabled and/or used by internal Twilio/Segment employees. Features cannot be used for Partner builds.
 - `statsContext` - An object, containing a `statsClient` and `tags`. Stats can only be used by internal Twilio/Segment employees. Stats cannot be used for Partner builds.
 - `logger` - Logger can only be used by internal Twilio/Segment employees. Logger cannot be used for Partner builds.
-- `dataFeedCache` - DataFeedCache can only be used by internal Twilio/Segment employees. DataFeedCache cannot be used for Partner builds.
+- `engageDestinationCache` - EngageDestinationCache can only be used by internal Twilio/Segment employees. EngageDestinationCache should not be used for Partner builds.
 - `transactionContext` - An object, containing transaction variables and a method to update transaction variables which are required for few segment developed actions. Transaction Context cannot be used for Partner builds.
 - `stateContext` - An object, containing context variables and a method to get and set context variables which are required for few segment developed actions. State Context cannot be used for Partner builds.
 

packages/actions-shared/src/engage/utils/CachedResponse.ts

@@ -0,0 +1,62 @@
+export enum CachedResponseType {
+  Success = 0,
+  Error = 1
+}
+
+export class CachedValueSerializationError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'CachedValueSerializationError'
+  }
+}
+
+export class CachedValue {
+  public status: number
+  public type: CachedResponseType
+  protected seperator = ':-:'
+
+  constructor(status: number) {
+    this.status = status
+    this.type = CachedResponseType.Success
+  }
+
+  serialize(): string {
+    return `${this.type}${this.seperator}${this.status}`
+  }
+}
+
+export class CachedError extends CachedValue {
+  public message: string
+  public code: string
+  constructor(status: number, message: string, code: string) {
+    super(status)
+    this.type = CachedResponseType.Error
+    this.code = code
+    this.message = message
+  }
+
+  serialize(): string {
+    return `${super.serialize()}${this.seperator}${this.message}${this.seperator}${this.code}`
+  }
+}
+
+export class CachedValueFactory {
+  public static fromString(value: string): CachedValue | CachedError {
+    const parts = value.split(':-:')
+    if (parts.length < 2) {
+      throw new CachedValueSerializationError(`Invalid cached value ${value}`)
+    }
+    const [type, status] = parts
+    if (CachedResponseType.Success === +type) {
+      return new CachedValue(+status)
+    } else if (CachedResponseType.Error === +type) {
+      if (parts.length < 4) {
+        throw new CachedValueSerializationError(`Invalid cached value ${value}`)
+      }
+      const [message, code] = parts.slice(2)
+      return new CachedError(+status, message, code)
+    } else {
+      throw new CachedValueSerializationError(`Invalid cached value ${value}`)
+    }
+  }
+}

packages/actions-shared/src/engage/utils/EngageActionPerformer.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { RequestClient } from '@segment/actions-core/create-request-client'
-import { ExecuteInput } from '@segment/actions-core/destination-kit'
+import { EngageDestinationCache, ExecuteInput } from '@segment/actions-core/destination-kit'
 import { MaybePromise } from '@segment/actions-core/destination-kit/types'
 import { EngageLogger } from './EngageLogger'
 import { EngageStats } from './EngageStats'
@@ -17,9 +17,9 @@ import truncate from 'lodash/truncate'
  * Base class for all Engage Action Performers. Supplies common functionality like logger, stats, request, operation tracking
  */
 export abstract class EngageActionPerformer<TSettings = any, TPayload = any, TReturn = any> {
-  readonly logger: EngageLogger = new EngageLogger(this)
-  readonly statsClient: EngageStats = new EngageStats(this)
-  readonly dataFeedCache = this.executeInput.dataFeedCache
+  readonly logger: EngageLogger
+  readonly statsClient: EngageStats
+  readonly engageDestinationCache: EngageDestinationCache | undefined
   readonly currentOperation: OperationContext | undefined
 
   readonly payload: TPayload
@@ -28,6 +28,9 @@ export abstract class EngageActionPerformer<TSettings = any, TPayload = any, TRe
   constructor(readonly requestClient: RequestClient, readonly executeInput: ExecuteInput<TSettings, TPayload>) {
     this.payload = executeInput.payload
     this.settings = executeInput.settings
+    this.engageDestinationCache = executeInput.engageDestinationCache
+    this.logger = new EngageLogger(this)
+    this.statsClient = new EngageStats(this)
   }
 
   beforePerform?(): void | Promise<void>

packages/actions-shared/src/engage/utils/EngageStats.ts

@@ -23,17 +23,6 @@ export class EngageStats extends OperationStats {
 
   onTry(ctx: OperationStatsContext): () => void {
     const res = super.onTry(ctx)
-    ctx.sharedContext.tags.push(
-      `space_id:${this.actionPerformer.settings.spaceId}`,
-      `projectid:${this.actionPerformer.settings.sourceId}`,
-      `computation_id:${this.actionPerformer.payload.segmentComputationId}`,
-      `settings_region:${this.actionPerformer.settings.region}`,
-      `channel:${this.actionPerformer.getChannelType()}`
-    )
-    const correlation_id =
-      this.actionPerformer.payload.customArgs?.correlation_id ||
-      this.actionPerformer.payload.customArgs?.__segment_internal_correlation_id__
-    if (correlation_id) ctx.sharedContext.tags.push(`correlation_id:${correlation_id}`)
 
     //for operations like request which can be used in multiple places, we need to have operation_path tag that will show where this operation is invoked from
     const parentOperation = (ctx as OperationContext).parent
@@ -58,7 +47,6 @@ export class EngageStats extends OperationStats {
   stats(statsArgs: StatsArgs): void {
     if (!this.statsClient) return
     const { method: statsMethod, metric, value, tags } = statsArgs
-    //[statsArgs.method, statsArgs.metric, statsArgs.value, statsArgs.tags]
     let statsFunc = this.statsClient?.[statsMethod || 'incr'].bind(this.statsClient)
     if (!statsFunc)
       switch (
@@ -68,23 +56,20 @@ export class EngageStats extends OperationStats {
         case 'incr':
           statsFunc = this.statsClient?.incr.bind(this.statsClient)
           break
-          break
         case 'histogram':
           statsFunc = this.statsClient?.histogram.bind(this.statsClient)
           break
-          break
         case 'set':
           statsFunc = this.statsClient?.set.bind(this.statsClient)
           break
-          break
         default:
           break
       }
 
     statsFunc?.(
       `${this.actionPerformer.getIntegrationStatsName()}.${metric}`,
       typeof value === 'undefined' ? 1 : value,
-      [...(this.actionPerformer.executeInput.statsContext?.tags || []), ...(tags ?? [])]
+      this.mergeTags(this.actionPerformer.executeInput.statsContext?.tags, tags)
     )
   }