:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
fix(workflows): keep queue and priority across email queue retries (#127102)
Michael Reichenbache60d2995971e
diff --git a/docs/internal/workflows-email-sending-tiers.md b/docs/internal/workflows-email-sending-tiers.mdindex b511cea77ec8..1fe69735e08b 100644--- a/docs/internal/workflows-email-sending-tiers.md+++ b/docs/internal/workflows-email-sending-tiers.md@@ -65,6 +65,7 @@ Decay, suspension drops, admin recomputes, and the backfill stay silent.- The batch audience cap is decided when the batch is dispatched. Adding an email step to the workflow while a batch is queued does not re-cap it; the send-time buckets still cap every email at execution. This is why enforcement requires the worker caps to be deployed (see the rollout order).- Test-panel sends bypass the team buckets on purpose, matching the per-workflow rate limit.+- Rescheduled emails keep their email queue priority while waiting. After a team-cap, workflow-pacing, or SES-throttle retry, the workflow restores its origin queue and priority when it next leaves the email queue. A push notification retried while the workflow is on the email queue behaves the same way and waits at the priority of its own message category.- The buckets are token buckets: a full idle bucket plus refill allows up to roughly twice the stated cap in the very first period. The bucket TTLs exceed the refill periods so this does not recur from idling.- A denied send parks until every short bucket has refilled enough to cover it, instead of retrying on a fixed few-minute cadence.The computed wait is capped at one hour and then jittered 1x to 2x, so a parked send can wait just under two hours between attempts.diff --git a/nodejs/src/cdp/services/hog-executor-async.service.ts b/nodejs/src/cdp/services/hog-executor-async.service.tsindex 8a06dcfcf045..d4286dab465b 100644--- a/nodejs/src/cdp/services/hog-executor-async.service.ts+++ b/nodejs/src/cdp/services/hog-executor-async.service.ts@@ -30,7 +30,12 @@ import { mergeSecretHeaders, resolveSecretHeaders } from '../utils/secret-headerimport { resolveStandardWebhooksKey, signStandardWebhooksRequest } from '../utils/standard-webhooks'import { HogExecutorExecuteOptions, HogExecutorPreviousResult, HogExecutorService } from './hog-executor.service'import { HogInputsService } from './hog-inputs.service'-import { EMAIL_QUEUE_PRIORITY, cdpEmailQueuedTotal, getEmailQueuePriorityClass } from './messaging/email-priority'+import {+ EMAIL_QUEUE_PRIORITY,+ cdpEmailQueuedTotal,+ getEmailQueuePriority,+ getEmailQueuePriorityClass,+} from './messaging/email-priority'import { EmailService } from './messaging/email.service'import { PushNotificationService } from './messaging/push-notification.service'import { RecipientTokensService, preferencesTokenSourceForInvocation } from './messaging/recipient-tokens.service'@@ -163,6 +168,9 @@ export class HogExecutorAsyncService {nextInvocation,options?.isTest ?? false)+ if (invocation.queue === 'email' && !result.finished) {+ this.keepPushRetryInEmailQueueOrder(result, invocation)+ }} else if (queueParamsType === 'email') {// Route to the email queue unless this is a test run: tests execute in-process and// never enqueue, so routing would leave the job unworked.@@ -179,8 +187,8 @@ export class HogExecutorAsyncService {// the current action's metadata so a throttle retry re-queues under this// send's class rather than the previous email action's.if (invocation.queue === 'email') {- nextInvocation.queuePriority =- EMAIL_QUEUE_PRIORITY[getEmailQueuePriorityClass(nextInvocation.hogFunction.metadata)]+ nextInvocation.queueMetadata = invocation.queueMetadata+ nextInvocation.queuePriority = getEmailQueuePriority(nextInvocation.hogFunction.metadata)}// isTest is forwarded so a test send stays out of the email's engagement tracking.result = await this.deps.emailService.executeSendEmail(nextInvocation, options?.isTest ?? false)@@ -324,6 +332,15 @@ export class HogExecutorAsyncService {return result}+ private keepPushRetryInEmailQueueOrder(+ result: CyclotronJobInvocationResult<CyclotronJobInvocationHogFunction>,+ entryInvocation: CyclotronJobInvocationHogFunction+ ): void {+ const { originQueue, originPriority } = entryInvocation.queueMetadata ?? {}+ result.invocation.queueMetadata = { ...result.invocation.queueMetadata, originQueue, originPriority }+ result.invocation.queuePriority = getEmailQueuePriority(result.invocation.hogFunction.metadata)+ }+private routeToQueue(invocation: CyclotronJobInvocationHogFunction,targetQueue: string,diff --git a/nodejs/src/cdp/services/hogflows/hogflow-executor.service.test.ts b/nodejs/src/cdp/services/hogflows/hogflow-executor.service.test.tsindex 49c0688590be..aec05b4a71df 100644--- a/nodejs/src/cdp/services/hogflows/hogflow-executor.service.test.ts+++ b/nodejs/src/cdp/services/hogflows/hogflow-executor.service.test.ts@@ -1,4 +1,5 @@// sort-imports-ignore+import { SESv2Client, TooManyRequestsException } from '@aws-sdk/client-sesv2'import { PosthogJwtAudience } from '~/cdp/utils/jwt-utils'import { ScopedServiceJwt } from '~/cdp/utils/scoped-service-jwt'import { DateTime, Duration } from 'luxon'@@ -31,6 +32,7 @@ import { EmailSuppressionService, emailSuppressionConfigFromEnv } from '../messaimport { EmailValidationService } from '../messaging/email-validation.service'import { EmailService } from '../messaging/email.service'import { EmailTrackingCodeSigner } from '../messaging/helpers/tracking-code'+import { PushNotificationFetchUtils, PushNotificationService } from '../messaging/push-notification.service'import { RecipientPreferencesService } from '../messaging/recipient-preferences.service'import { RecipientTokensService } from '../messaging/recipient-tokens.service'import { HogFlowExecutorService, createHogFlowInvocation } from './hogflow-executor.service'@@ -48,6 +50,8 @@ jest.mock('~/common/utils/request', () => {}})+type TrackedPushFetch = PushNotificationFetchUtils['trackedFetch']+const cleanLogs = (logs: string[]): string[] => {// Replaces the function time with a fixed value to simplify testingreturn logs.map((log) => log.replace(/Function completed in \d+(\.\d+)?ms/, 'Function completed in REPLACEDms'))@@ -61,8 +65,10 @@ describe('Hogflow Executor', () => {let team: Teamlet integrationId: numberconst mockFetch = jest.mocked(fetch)+ const mockPushProviderFetch = jest.fn<ReturnType<TrackedPushFetch>, Parameters<TrackedPushFetch>>()beforeEach(async () => {+ mockPushProviderFetch.mockReset()const fixedTime = DateTime.fromObject({ year: 2025, month: 1, day: 1 }, { zone: 'UTC' })jest.spyOn(Date, 'now').mockReturnValue(fixedTime.toMillis())@@ -127,7 +133,19 @@ describe('Hogflow Executor', () => {hogInputsService,emailService,recipientTokensService,- pushNotificationService: undefined as any,+ pushNotificationService: new PushNotificationService(+ hub.integrationManager,+ hub.encryptedFields,+ {+ trackedFetch: mockPushProviderFetch,+ maxFetchTimeoutMs: 10000,+ maxRetries: 3,+ backoffBaseMs: 1000,+ backoffMaxMs: 30000,+ },+ undefined as any,+ undefined as any+ ),})const hogFunctionTemplateManager = new HogFunctionTemplateManagerService(hub.postgres)@@ -3219,7 +3237,11 @@ describe('Hogflow Executor', () => {})describe('email queue routing', () => {- it('should route email actions to the email queue', async () => {+ afterEach(() => {+ jest.restoreAllMocks()+ })++ const insertEmailSetup = async (provider: 'maildev' | 'ses'): Promise<void> => {await insertIntegration(hub.postgres, team.id, {id: integrationId,kind: 'email',@@ -3228,10 +3250,9 @@ describe('Hogflow Executor', () => {name: 'Test User',domain: 'posthog.com',verified: true,- provider: 'maildev',+ provider,},})-await insertHogFunctionTemplate(hub.postgres, {id: 'template-email-routing-test',name: 'Email Routing Test',@@ -3256,6 +3277,29 @@ describe('Hogflow Executor', () => {},],})+ }++ const emailAction = (subject: string) =>+ ({+ type: 'function_email',+ config: {+ template_id: 'template-email-routing-test',+ inputs: {+ email: {+ value: {+ to: { email: '[email protected]', name: 'Recipient' },+ from: { integrationId, email: '[email protected]' },+ subject,+ text: `${subject} text`,+ html: `<p>${subject}</p>`,+ },+ },+ },+ },+ }) as const++ it('should route email actions to the email queue', async () => {+ await insertEmailSetup('maildev')const hogFlow = new FixtureHogFlowBuilder().withTeamId(team.id)@@ -3269,23 +3313,7 @@ describe('Hogflow Executor', () => {filters: HOG_FILTERS_EXAMPLES.no_filters.filters ?? {},},},- email_1: {- type: 'function_email',- config: {- template_id: 'template-email-routing-test',- inputs: {- email: {- value: {- to: { email: '[email protected]', name: 'Recipient' },- from: { integrationId, email: '[email protected]' },- subject: 'Test Email',- text: 'Test',- html: '<p>Test</p>',- },- },- },- },- },+ email_1: emailAction('Test Email'),},edges: [{ from: 'trigger', to: 'email_1', type: 'continue' },@@ -3311,43 +3339,54 @@ describe('Hogflow Executor', () => {expect(result.invocation.queueParameters?.type).toBe('email')})- it('should complete the full round-trip: hogflow → email queue → email sent → workflow continues', async () => {+ it('returns consecutive emails and push retries to their origin queue and priority: hogflow → email queue → messages sent → workflow continues', async () => {+ await insertEmailSetup('ses')+ const pushIntegrationId = uniqueTestId()await insertIntegration(hub.postgres, team.id, {- id: integrationId,- kind: 'email',- config: {- email: '[email protected]',- name: 'Test User',- domain: 'posthog.com',- verified: true,- provider: 'maildev',+ id: pushIntegrationId,+ kind: 'firebase',+ config: { project_id: 'test-project' },+ sensitive_config: { access_token: 'test-access-token' },+ })+ const fcmResponse = (status: number): Awaited<ReturnType<TrackedPushFetch>> => ({+ fetchError: null,+ fetchResponse: {+ status,+ headers: {},+ json: () => Promise.resolve({}),+ text: () => Promise.resolve('{}'),+ dump: () => Promise.resolve(),},+ fetchDuration: 10,})+ mockPushProviderFetch+ .mockResolvedValueOnce(fcmResponse(503))+ .mockResolvedValueOnce(fcmResponse(200))+ .mockResolvedValueOnce(fcmResponse(503))+ .mockResolvedValueOnce(fcmResponse(200))+ const sesSend = jest.spyOn(SESv2Client.prototype, 'send') as jest.SpyInstance+ sesSend+ .mockResolvedValueOnce({ MessageId: 'first-email' })+ .mockRejectedValueOnce(new TooManyRequestsException({ $metadata: {}, message: 'Too many requests' }))+ .mockResolvedValue({ MessageId: 'follow-up-email' })await insertHogFunctionTemplate(hub.postgres, {- id: 'template-email-routing-test',- name: 'Email Routing Test',- code: `sendEmail(inputs.email)`,+ id: 'template-push-queue-routing-test',+ name: 'Push Routing Test',+ code: `let res := sendPushNotification({'integrationIds': [inputs.integrationId], 'distinctId': 'distinct-id', 'payload': {'title': 'Hi', 'body': 'Hello'}})+if (not res.success) { throw Error(res.error) }`,inputs_schema: [- {- type: 'native_email',- key: 'email',- label: 'Email message',- integration: 'email',- required: true,- default: {- to: { email: '', name: '' },- from: { email: '', name: '' },- subject: '',- text: 'Hello!',- html: '<div>Hello!</div>',- },- secret: false,- description: '',- templating: 'liquid',- },+ { type: 'string', key: 'integrationId', label: 'Channel', secret: false, required: true },],})+ const transactionalPush = {+ type: 'function_push',+ config: {+ template_id: 'template-push-queue-routing-test',+ message_category_type: 'transactional',+ inputs: { integrationId: { value: pushIntegrationId } },+ },+ } as constconst hogFlow = new FixtureHogFlowBuilder().withTeamId(team.id)@@ -3361,21 +3400,15 @@ describe('Hogflow Executor', () => {filters: HOG_FILTERS_EXAMPLES.no_filters.filters ?? {},},},- email_1: {- type: 'function_email',+ email_1: emailAction('Test Email'),+ push_1: transactionalPush,+ push_2: transactionalPush,+ email_2: emailAction('Follow-up Email'),+ webhook: {+ type: 'function',config: {- template_id: 'template-email-routing-test',- inputs: {- email: {- value: {- to: { email: '[email protected]', name: 'Recipient' },- from: { integrationId, email: '[email protected]' },- subject: 'Test Email',- text: 'Test text',- html: '<p>Test html</p>',- },- },- },+ template_id: 'template-test-hogflow-executor',+ inputs: { name: { value: 'Mr Debug' } },},},exit: {@@ -3385,17 +3418,29 @@ describe('Hogflow Executor', () => {},edges: [{ from: 'trigger', to: 'email_1', type: 'continue' },- { from: 'email_1', to: 'exit', type: 'continue' },+ { from: 'email_1', to: 'push_1', type: 'continue' },+ { from: 'push_1', to: 'push_2', type: 'continue' },+ { from: 'push_2', to: 'email_2', type: 'continue' },+ { from: 'email_2', to: 'webhook', type: 'continue' },+ { from: 'webhook', to: 'exit', type: 'continue' },],}).build()- const invocation = createExampleHogFlowInvocation(hogFlow, {- event: {- ...createHogExecutionGlobals().event,- event: '$pageview',+ const invocation = createExampleHogFlowInvocation(+ hogFlow,+ {+ event: {+ ...createHogExecutionGlobals().event,+ event: '$pageview',+ },},- })+ {+ properties: {+ '$device_push_subscription_test-project': hub.encryptedFields.encrypt('device-token'),+ },+ }+ )// A watcher-degraded flow enters at priority 2; the routing must stash that// exact value, not the 0 that per-action result clones reset queuePriority to@@ -3411,19 +3456,77 @@ describe('Hogflow Executor', () => {expect(hogflowResult.invocation.queuePriority).toBe(1)expect(hogflowResult.invocation.queueMetadata?.originPriority).toBe(2)- // Step 2: Email worker picks up the job (queue === 'email') — should send inline and continue+ const results = []let emailResult = await executor.execute(hogflowResult.invocation)- while (!emailResult.finished) {+ results.push(emailResult)+ while (!emailResult.finished && emailResult.invocation.queue === 'email') {emailResult = await executor.execute(emailResult.invocation)+ results.push(emailResult)}+ expect(emailResult.invocation).toMatchObject({ queue: 'hogflow', queuePriority: 2 })+ const rescheduledOnEmailQueue = results+ .filter((result) => result.invocation.queue === 'email')+ .map(({ invocation }) => ({ priority: invocation.queuePriority, metadata: invocation.queueMetadata }))+ expect(rescheduledOnEmailQueue).toEqual([+ { priority: 0, metadata: { originQueue: 'hogflow', originPriority: 2, tries: 1 } },+ { priority: 0, metadata: { originQueue: 'hogflow', originPriority: 2, tries: 1 } },+ { priority: 1, metadata: expect.objectContaining({ originQueue: 'hogflow', originPriority: 2 }) },+ ])++ let workflowResult = emailResult+ while (!workflowResult.finished) {+ workflowResult = await executor.execute(workflowResult.invocation)+ results.push(workflowResult)+ }+ expect(workflowResult.error).toBeUndefined()++ const sentMetrics = results+ .flatMap((r) => r.metrics)+ .map((m) => m.metric_name)+ .filter((name) => name === 'email_sent' || name === 'push_sent')+ expect(sentMetrics).toEqual(['email_sent', 'push_sent', 'push_sent', 'email_sent'])+ expect(sesSend).toHaveBeenCalledTimes(3)+ expect(mockPushProviderFetch).toHaveBeenCalledTimes(4)+ })++ it('keeps the team cap label on the delayed email only, not on the email after it', async () => {+ await insertEmailSetup('ses')+ const sesSend = jest.spyOn(SESv2Client.prototype, 'send') as jest.SpyInstance+ sesSend+ .mockResolvedValueOnce({ MessageId: 'capped-email' })+ .mockRejectedValueOnce(new TooManyRequestsException({ $metadata: {}, message: 'Too many requests' }))++ const hogFlow = new FixtureHogFlowBuilder()+ .withTeamId(team.id)+ .withExitCondition('exit_only_at_end')+ .withWorkflow({+ actions: {+ trigger: {+ type: 'trigger',+ config: { type: 'event', filters: HOG_FILTERS_EXAMPLES.no_filters.filters ?? {} },+ },+ email_1: emailAction('Capped Email'),+ email_2: emailAction('Next Email'),+ },+ edges: [+ { from: 'trigger', to: 'email_1', type: 'continue' },+ { from: 'email_1', to: 'email_2', type: 'continue' },+ { from: 'email_2', to: 'exit', type: 'continue' },+ ],+ })+ .build()+ const invocation = createExampleHogFlowInvocation(hogFlow, {+ event: { ...createHogExecutionGlobals().event, event: '$pageview' },+ })++ const routed = await executor.execute(invocation)+ // As if the team sending cap had delayed email_1 on the email queue.+ routed.invocation.queueMetadata = { ...routed.invocation.queueMetadata, teamCapped: true }- // Workflow should complete- expect(emailResult.finished).toBe(true)- expect(emailResult.error).toBeUndefined()+ const result = await executor.execute(routed.invocation)- // Verify email_sent metric was emitted- const emailSentMetrics = emailResult.metrics.filter((m) => m.metric_name === 'email_sent')- expect(emailSentMetrics).toHaveLength(1)+ expect(result.invocation.state.currentAction?.id).toBe('email_2')+ expect(result.invocation.queueMetadata).toEqual({ originQueue: 'hogflow', originPriority: 0 })})})})diff --git a/nodejs/src/cdp/services/hogflows/hogflow-executor.service.ts b/nodejs/src/cdp/services/hogflows/hogflow-executor.service.tsindex c15bf16546a8..2a6bfa998cfc 100644--- a/nodejs/src/cdp/services/hogflows/hogflow-executor.service.ts+++ b/nodejs/src/cdp/services/hogflows/hogflow-executor.service.ts@@ -76,6 +76,19 @@ const TRIGGER_MISMATCH_EXITS: ReadonlySet<string> = new Set(['exit_on_trigger_not_matched_or_conversion',])+// The email service sets teamCapped when the team sending cap delays one send, and that send reads it from the+// job's stored metadata. The actions after it in the same dequeue start from this executor's result, so the+// flag stays off them. Otherwise their queue waits would also count as cap delays.+function withoutTeamCapped(+ metadata: CyclotronJobInvocationHogFlow['queueMetadata']+): CyclotronJobInvocationHogFlow['queueMetadata'] {+ if (!metadata || !('teamCapped' in metadata)) {+ return metadata+ }+ const { teamCapped: _teamCapped, ...rest } = metadata+ return rest+}+export function createHogFlowInvocation(globals: HogFunctionInvocationGlobals,hogFlow: HogFlow,@@ -686,6 +699,7 @@ export class HogFlowExecutorService {// run whose email action isn't the first action executed.const result = createInvocationResult<CyclotronJobInvocationHogFlow>(invocation, {queuePriority: invocation.queuePriority,+ queueMetadata: invocation.queue === 'email' ? withoutTeamCapped(invocation.queueMetadata) : undefined,})result.finished = false // Typically we are never finished unless we error or exitdiff --git a/nodejs/src/cdp/services/messaging/email-priority.ts b/nodejs/src/cdp/services/messaging/email-priority.tsindex b4f3353e94a7..6854218eb47b 100644--- a/nodejs/src/cdp/services/messaging/email-priority.ts+++ b/nodejs/src/cdp/services/messaging/email-priority.ts@@ -39,6 +39,10 @@ export function getEmailQueuePriorityClass(metadata: HogFunctionType['metadata']return metadata?.message_category_type === 'transactional' ? 'fast' : 'bulk'}+export function getEmailQueuePriority(metadata: HogFunctionType['metadata']): number {+ return EMAIL_QUEUE_PRIORITY[getEmailQueuePriorityClass(metadata)]+}+export const cdpEmailQueuedTotal = new Counter({name: 'cdp_email_queued_total',help: 'Total emails routed to the dedicated email queue',diff --git a/nodejs/src/cdp/services/messaging/email.service.test.ts b/nodejs/src/cdp/services/messaging/email.service.test.tsindex de49199c5ee9..f75e6ade4d29 100644--- a/nodejs/src/cdp/services/messaging/email.service.test.ts+++ b/nodejs/src/cdp/services/messaging/email.service.test.ts@@ -272,6 +272,7 @@ describe('EmailService', () => {stack: [],} as anyinvocation.queueParameters = createEmailParams({ from: { integrationId: 1 } })+ invocation.queueMetadata = { originQueue: 'hogflow', originPriority: 2 }// Mock SES v2 send to avoid actual AWS callssendEmailSpy = jest.spyOn(service.sesV2Client!, 'send') as any@@ -546,6 +547,7 @@ describe('EmailService', () => {expect(scheduledMs).toBeGreaterThanOrEqual(before + 400)expect(scheduledMs).toBeLessThan(before + 2000)expect(result.invocation.queueParameters).toEqual(invocation.queueParameters)+ expect(result.invocation.queueMetadata).toEqual(invocation.queueMetadata)// No business metric emitted on throttle — the eventual retry// will produce email_sent.expect(result.metrics ?? []).toEqual([])@@ -740,6 +742,7 @@ describe('EmailService', () => {// The reschedule must carry the email payload forward: without queueParameters the// retry has nothing to send and the throttled email is dropped rather than delayed.expect(result.invocation.queueParameters).toEqual(invocation.queueParameters)+ expect(result.invocation.queueMetadata).toEqual(invocation.queueMetadata)// Bracketed against both ends of the call, so the bounds hold the delay itself// and not the time the call took.const scheduledMs = result.invocation.queueScheduledAt!.toMillis()@@ -978,7 +981,7 @@ describe('EmailService', () => {// The reschedule must carry the email payload forward, same as the workflow limit.expect(result.invocation.queueParameters).toEqual(invocation.queueParameters)// The flag labels the eventual send's queue wait, so alerts can leave out the cap delay.- expect(result.invocation.queueMetadata).toMatchObject({ teamCapped: true })+ expect(result.invocation.queueMetadata).toEqual({ ...invocation.queueMetadata, teamCapped: true })const scheduledMs = result.invocation.queueScheduledAt!.toMillis()expect(scheduledMs).toBeGreaterThanOrEqual(before + minMs)expect(scheduledMs).toBeLessThan(before + maxMs + 5000)diff --git a/nodejs/src/cdp/services/messaging/email.service.ts b/nodejs/src/cdp/services/messaging/email.service.tsindex c5989ba5a29a..9967187c63fa 100644--- a/nodejs/src/cdp/services/messaging/email.service.ts+++ b/nodejs/src/cdp/services/messaging/email.service.ts@@ -702,6 +702,7 @@ export class EmailService {// send. Mirrors the fetch-retry (`result.invocation.queueParameters = params`) and// queue-routing paths, which re-attach the same way.result.invocation.queueParameters = params+ result.invocation.queueMetadata = invocation.queueMetadataconst retryDelayMs = pickReservedRetryDelayMs(claim.retryAfterMs, refillPerSecond, claim.reserved)emailReservedParkMs.labels('workflow-email').observe(retryDelayMs)result.invocation.queueScheduledAt = DateTime.utc().plus({ milliseconds: retryDelayMs })@@ -805,6 +806,7 @@ export class EmailService {throttled = trueresult.finished = falseresult.invocation.queueParameters = params+ result.invocation.queueMetadata = invocation.queueMetadataresult.invocation.queueScheduledAt = DateTime.utc().plus({ milliseconds: error.retryAfterMs })addLog('warn', `SES rate-limited (${error.errorCode}); rescheduling email in ${error.retryAfterMs}ms`)} else {diff --git a/nodejs/tests/fixtures/hog-bytecode/1b3f99defea3027176062c76e92e8779a3d2d4c39e28f7d002d66cdbfb8cd8e2.json b/nodejs/tests/fixtures/hog-bytecode/1b3f99defea3027176062c76e92e8779a3d2d4c39e28f7d002d66cdbfb8cd8e2.jsonnew file mode 100644index 000000000000..e21a84fee743--- /dev/null+++ b/nodejs/tests/fixtures/hog-bytecode/1b3f99defea3027176062c76e92e8779a3d2d4c39e28f7d002d66cdbfb8cd8e2.json@@ -0,0 +1 @@+["_H",1,32,"integrationIds",32,"integrationId",32,"inputs",1,2,43,1,32,"distinctId",32,"distinct-id",32,"payload",32,"title",32,"Hi",32,"body",32,"Hello",42,2,42,3,2,"sendPushNotification",1,36,0,32,"success",45,5,40,9,36,0,32,"error",45,2,"Error",1,49,35]