@ductape/sdk 0.0.4-v99 → 0.0.5

package/dist/processor/services/processor.service.js

@@ -46,6 +46,7 @@ var __rest = (this && this.__rest) || function (s, e) {
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
 const products_service_1 = __importDefault(require("../../products/services/products.service"));
 const types_1 = require("../../types");
@@ -54,6 +55,7 @@ const inputs_service_1 = __importDefault(require("../../inputs/inputs.service"))
 const processor_utils_1 = require("../utils/processor.utils");
 const axios_1 = __importDefault(require("axios"));
 const processorApi_service_1 = require("../../api/services/processorApi.service");
+const cache_service_1 = require("../../cache/cache.service");
 const expo_client_1 = __importDefault(require("../../clients/expo.client"));
 const handlebars_1 = require("handlebars");
 const string_utils_1 = require("../../products/utils/string.utils");
@@ -86,8 +88,19 @@ async function loadJWT() {
     }
     return null;
 }
+/** Only log when DUCTAPE_DEBUG is set to avoid sync I/O and serialization cost in hot path */
+const _processorDebug = typeof process !== 'undefined' && (((_a = process.env) === null || _a === void 0 ? void 0 : _a.DUCTAPE_DEBUG) === 'true' || ((_b = process.env) === null || _b === void 0 ? void 0 : _b.DUCTAPE_DEBUG) === '1');
+const debugLog = _processorDebug ? (...args) => console.log(...args) : () => { };
 class ProcessorService {
-    constructor({ workspace_id, public_key, user_id, token, env_type, private_key, access_key, redis_client, queues }) {
+    constructor({ workspace_id, public_key, user_id, token, env_type, private_key, access_key, redis_client, queues, preInitializedProductBuilder }) {
+        /** Reuse broker connections when multiple produce steps use the same broker (avoids ~1–3s connection setup per step). Never logged or exposed. */
+        this.brokerServicePool = new Map();
+        /** Reuse SMTP transporter so we don't open a new connection per email (avoids multi-second handshake per send). Never logged or exposed. */
+        this.mailTransporterPool = new Map();
+        /** Reuse Firebase Admin app per project (avoids re-init per push). Never logged or exposed. */
+        this.firebaseAppPool = new Map();
+        /** Reuse SMS client per config (Twilio/Nexmo/Plivo). Never logged or exposed. */
+        this.smsClientPool = new Map();
         this.workspace_id = workspace_id;
         this.public_key = public_key;
         this.user_id = user_id;
@@ -95,13 +108,15 @@ class ProcessorService {
         this.accessKey = access_key;
         this.token = token;
         this.published = false;
-        this.productBuilderService = new products_service_1.default({
+        this.productBuilderService = preInitializedProductBuilder !== null && preInitializedProductBuilder !== void 0 ? preInitializedProductBuilder : new products_service_1.default({
             workspace_id,
             public_key,
             user_id,
             token,
             env_type,
             redis_client,
+            access_key,
+            workspace_private_key: private_key || undefined,
         });
         this.appBuilderService = new app_service_1.default({
             workspace_id,
@@ -132,9 +147,20 @@ class ProcessorService {
         this.requestTrackerService = request_service_1.default.getInstance(redis_client);
         this.processorApiService = new processorApi_service_1.ProcessorApiService(env_type);
         this.environment = env_type;
-        // Store redis client for job state management
+        // Initialize CacheService
+        this.cacheService = new cache_service_1.CacheService({
+            workspace_id,
+            public_key,
+            user_id,
+            token,
+            env_type,
+        });
+        // Connect CacheService to Redis if available
         if (redis_client) {
             this.redisClient = redis_client;
+            // Note: CacheService.connectRedis() requires a URL string, but we have a client instance
+            // For now, CacheService will work with remote cache only
+            // TODO: Consider adding a method to CacheService to accept an existing Redis client
         }
         // Start healthcheck workers only if product tag is available
         if (redis_client && this.productTag) {
@@ -144,6 +170,192 @@ class ProcessorService {
             this.queues = queues;
         }
     }
+    /**
+     * Pool key for broker service reuse (same broker type + config => same connection).
+     */
+    getBrokerPoolKey(type, config) {
+        var _a;
+        const configKey = (config === null || config === void 0 ? void 0 : config.url) || (config === null || config === void 0 ? void 0 : config.host) || ((_a = config === null || config === void 0 ? void 0 : config.brokers) === null || _a === void 0 ? void 0 : _a[0]) || JSON.stringify(config !== null && config !== void 0 ? config : {});
+        return `${type}:${configKey}`;
+    }
+    /**
+     * Get or create a broker service instance so we reuse the same connection for the same broker.
+     */
+    async getBrokerServiceForPublish(type, config) {
+        const poolKey = this.getBrokerPoolKey(type, config);
+        const existing = this.brokerServicePool.get(poolKey);
+        if (existing)
+            return existing;
+        const createBrokerService = await loadBrokerService();
+        if (!createBrokerService)
+            throw new Error('Broker service not loaded (e.g. browser).');
+        const service = createBrokerService(type, config);
+        this.brokerServicePool.set(poolKey, service);
+        return service;
+    }
+    /**
+     * Disconnect all pooled broker connections (e.g. at end of workflow run).
+     * Safe to call if pool is empty or a broker has no disconnect().
+     */
+    async disconnectBrokerConnections() {
+        for (const service of this.brokerServicePool.values()) {
+            try {
+                const disconnect = service.disconnect;
+                if (typeof disconnect === 'function')
+                    await disconnect();
+            }
+            catch (_a) {
+                // Non-fatal
+            }
+        }
+        this.brokerServicePool.clear();
+    }
+    /**
+     * Pool key for mail transporter reuse (host/port/user only; no password). Same SMTP config => same connection.
+     */
+    getMailTransporterPoolKey(auth) {
+        var _a, _b, _c, _d;
+        const h = (_a = auth === null || auth === void 0 ? void 0 : auth.host) !== null && _a !== void 0 ? _a : '';
+        const p = (_b = auth === null || auth === void 0 ? void 0 : auth.port) !== null && _b !== void 0 ? _b : '';
+        const u = (_d = (_c = auth === null || auth === void 0 ? void 0 : auth.auth) === null || _c === void 0 ? void 0 : _c.user) !== null && _d !== void 0 ? _d : '';
+        const secure = (auth === null || auth === void 0 ? void 0 : auth.secure) === true ? '1' : '0';
+        return `mail:${h}:${p}:${secure}:${u}`;
+    }
+    /**
+     * Get or create a mail transporter so we reuse the same SMTP connection instead of opening a new one per send.
+     */
+    async getMailTransporter(auth) {
+        const key = this.getMailTransporterPoolKey(auth);
+        const existing = this.mailTransporterPool.get(key);
+        if (existing)
+            return existing;
+        const transporter = await (0, processor_utils_1.mailerClient)(auth);
+        this.mailTransporterPool.set(key, transporter);
+        return transporter;
+    }
+    /**
+     * Close all pooled mail transporters (e.g. at end of workflow run). Safe if pool is empty.
+     */
+    async disconnectMailTransporters() {
+        for (const transporter of this.mailTransporterPool.values()) {
+            try {
+                const close = transporter.close;
+                if (typeof close === 'function')
+                    await close();
+            }
+            catch (_a) {
+                // Non-fatal
+            }
+        }
+        this.mailTransporterPool.clear();
+    }
+    /**
+     * Get or create Firebase Admin app by project_id so we reuse the same app per project (Expo client is already module-level singleton).
+     */
+    async getFirebaseApp(credentials) {
+        var _a, _b;
+        const creds = typeof credentials === 'string' ? JSON.parse(credentials) : credentials;
+        const projectId = (_a = creds === null || creds === void 0 ? void 0 : creds.project_id) !== null && _a !== void 0 ? _a : `fb-${String((_b = creds === null || creds === void 0 ? void 0 : creds.client_email) !== null && _b !== void 0 ? _b : '').slice(0, 20)}`;
+        const existing = this.firebaseAppPool.get(projectId);
+        if (existing)
+            return existing;
+        const admin = require('firebase-admin');
+        try {
+            const app = admin.app(projectId);
+            this.firebaseAppPool.set(projectId, app);
+            return app;
+        }
+        catch (_c) {
+            const app = admin.initializeApp({ credential: admin.credential.cert(credentials) }, projectId);
+            this.firebaseAppPool.set(projectId, app);
+            return app;
+        }
+    }
+    /**
+     * Close all pooled Firebase apps (e.g. at end of workflow run). Safe if pool is empty.
+     */
+    async disconnectFirebaseApps() {
+        for (const app of this.firebaseAppPool.values()) {
+            try {
+                const del = app.delete;
+                if (typeof del === 'function')
+                    await del();
+            }
+            catch (_a) {
+                // Non-fatal
+            }
+        }
+        this.firebaseAppPool.clear();
+    }
+    /**
+     * Pool key for SMS client (provider + identifier + sender; no secrets). Same config => reuse client.
+     */
+    getSmsClientPoolKey(config) {
+        var _a, _b, _c, _d;
+        const p = (_a = config === null || config === void 0 ? void 0 : config.provider) !== null && _a !== void 0 ? _a : '';
+        const id = (_c = (_b = config === null || config === void 0 ? void 0 : config.accountSid) !== null && _b !== void 0 ? _b : config === null || config === void 0 ? void 0 : config.apiKey) !== null && _c !== void 0 ? _c : '';
+        const sender = (_d = config === null || config === void 0 ? void 0 : config.sender) !== null && _d !== void 0 ? _d : '';
+        return `sms:${p}:${id}:${sender}`;
+    }
+    /**
+     * Get or create SMS client so we reuse Twilio/Nexmo/Plivo client per config.
+     */
+    async getSmsClient(config) {
+        const key = this.getSmsClientPoolKey(config);
+        const existing = this.smsClientPool.get(key);
+        if (existing)
+            return existing;
+        const SmsClientClass = await (0, sms_repo_1.loadSMSClient)();
+        if (!SmsClientClass)
+            throw new Error('SMS client not loaded (e.g. browser).');
+        const client = new SmsClientClass(config);
+        this.smsClientPool.set(key, client);
+        return client;
+    }
+    /**
+     * Clear pooled SMS clients (e.g. at end of workflow run). Safe if pool is empty.
+     */
+    async disconnectSmsClients() {
+        this.smsClientPool.clear();
+    }
+    /**
+     * Pre-warm broker connections for the given product/env and broker tags.
+     * Call this before step execution so the first produce step does not pay connection setup cost.
+     * Security: same auth as runBrokerPublish (product + env from caller). Secrets resolved in-memory
+     * only; no config/URLs/credentials logged or persisted. Pool is per-processor-instance (one run).
+     */
+    async warmBrokerConnections(options) {
+        const { product, env, brokerTags } = options;
+        if (brokerTags.length === 0)
+            return;
+        await this.productBuilderService.initializeProductByTag(product);
+        for (const brokerTag of brokerTags) {
+            try {
+                const broker = await this.productBuilderService.fetchMessageBroker(brokerTag);
+                if (!broker)
+                    continue;
+                const brokerEnv = broker.envs.find((el) => el.slug === env);
+                if (!brokerEnv)
+                    continue;
+                let brokerConfig = brokerEnv.config;
+                if (brokerConfig && (0, secrets_1.mightContainSecrets)(brokerConfig)) {
+                    const secretsService = (0, secrets_1.getSecretsService)();
+                    if (secretsService) {
+                        const resolved = await secretsService.resolve(brokerConfig, { env });
+                        brokerConfig = resolved.value;
+                    }
+                }
+                const service = await this.getBrokerServiceForPublish(brokerEnv.type, brokerConfig);
+                const connect = service.connect;
+                if (typeof connect === 'function')
+                    await connect();
+            }
+            catch (_a) {
+                // Intentionally no log: avoid leaking any error text (could contain URLs or backend details).
+                // Step will connect on first use or fail at runtime with same auth.
+            }
+        }
+    }
     /**
      * Start healthcheck workers for all products/environments after Redis is connected.
      * This is called automatically in the constructor if redisClient is present.
@@ -303,7 +515,7 @@ class ProcessorService {
             return res.data;
         }
         catch (e) {
-            console.log(e);
+            debugLog(e);
             throw new Error('Invalid/Expired token');
         }
     }
@@ -450,7 +662,13 @@ class ProcessorService {
             if (workspace_id !== this.workspace_id) {
                 throw new Error('Access Denied');
             }
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Product initialize - success', data: { product_id: this.productId }, status: types_1.LogEventStatus.SUCCESS }));
+            /*this.logService.add({
+              ...this.baseLogs,
+              ...additional_logs,
+              message: 'Product initialize - success',
+              data: { product_id: this.productId },
+              status: LogEventStatus.SUCCESS,
+            } as unknown as ILogData);*/
         }
         catch (e) {
             this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Product initialize - failed', data: e, status: types_1.LogEventStatus.FAIL }));
@@ -469,9 +687,9 @@ class ProcessorService {
             });
         }
         try {
-            console.log(`Initializing pricing for access tag: ${access_tag}`);
+            debugLog(`Initializing pricing for access tag: ${access_tag}`);
             const product_app = await this.productBuilderService.fetchApp(access_tag); // validate app exists
-            console.log(`Found product app: ${JSON.stringify(product_app)}`);
+            debugLog(`Found product app: ${JSON.stringify(product_app)}`);
             const app = await this.productBuilderService.fetchThirdPartyAppByAccessTag(product_app.access_tag);
             await this.pricingService.initializePricingByTag(product_app.pricing_tag, app._id);
             const { pricing_tag } = this.pricingService.fetchPricing();
@@ -489,7 +707,13 @@ class ProcessorService {
             if (!product_env) {
                 throw new Error(`Env ${env} not found`);
             }
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch environment - success', data: { slug: env, env: product_env }, status: types_1.LogEventStatus.SUCCESS }));
+            /*this.logService.add({
+              ...this.baseLogs,
+              ...additional_logs,
+              message: 'Fetch environment - success',
+              data: { slug: env, env: product_env },
+              status: LogEventStatus.SUCCESS,
+            } as unknown as ILogData);*/
             return product_env;
         }
         catch (e) {
@@ -545,7 +769,13 @@ class ProcessorService {
                     params,
                 });
             }
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Construct JSON payloads - success', data: { payload: (0, processor_utils_1.anonymizeObject)(payload) }, status: types_1.LogEventStatus.SUCCESS }));
+            /*this.logService.add({
+              ...this.baseLogs,
+              ...additional_logs,
+              message: 'Construct JSON payloads - success',
+              data: { payload: anonymizeObject(payload) },
+              status: LogEventStatus.SUCCESS,
+            } as unknown as ILogData);*/
             return payload;
         }
         catch (e) {
@@ -556,7 +786,6 @@ class ProcessorService {
     async generatePayload(obj, event, additional_logs, sample = [], index = {}, loopIndex = null) {
         try {
             const payload = {};
-            console.log('Payload Construction', { obj, event, sample, index, loopIndex });
             const keys = Object.keys(obj);
             for (let i = 0; i < keys.length; i++) {
                 const key = keys[i];
@@ -588,7 +817,6 @@ class ProcessorService {
                     });
                 }
             }
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Generate payload - success', data: { payload: (0, processor_utils_1.anonymizeObject)(payload) }, status: types_1.LogEventStatus.SUCCESS }));
             return payload;
         }
         catch (e) {
@@ -752,14 +980,14 @@ class ProcessorService {
             const placeholdersStr = match[1];
             const separator = match[2];
             const placeHolders = placeholdersStr.split(',').map((data) => data.trim());
-            console.log('placeHolders', { placeHolders, separator });
+            debugLog('placeHolders', { placeHolders, separator });
             const values = await Promise.all(placeHolders.map(async (holder) => {
                 return await this.generateStringValues(holder, app, additional_logs, sample, index, key, loopIndex);
             }));
             return values.join(separator);
         }
         else {
-            console.log('No match found');
+            debugLog('No match found');
         }
     }
     async uppercaseValue(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
@@ -772,7 +1000,7 @@ class ProcessorService {
             return resolvedValue.toUpperCase();
         }
         else {
-            //console.log('No match found');
+            //debugLog('No match found');
         }
     }
     async lowercaseValue(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
@@ -785,7 +1013,7 @@ class ProcessorService {
             return resolvedValue.toLowerCase();
         }
         else {
-            //console.log('No match found');
+            //debugLog('No match found');
         }
     }
     async dateFormatValue(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
@@ -801,7 +1029,7 @@ class ProcessorService {
             return (0, date_fns_1.format)(parsedDate, formatStr);
         }
         else {
-            //console.log('No match found');
+            //debugLog('No match found');
         }
     }
     async replaceValue(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
@@ -815,7 +1043,7 @@ class ProcessorService {
             return resolvedValue.split(searchStr).join(replaceStr);
         }
         else {
-            console.log('No match found');
+            debugLog('No match found');
         }
     }
     async substringValues(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
@@ -834,7 +1062,7 @@ class ProcessorService {
             return resolvedString.substring(start, end);
         }
         else {
-            console.log('No match found');
+            debugLog('No match found');
             return '';
         }
     }
@@ -849,7 +1077,7 @@ class ProcessorService {
             return resolvedString.trim();
         }
         else {
-            console.log('No match found');
+            debugLog('No match found');
             return '';
         }
     }
@@ -873,7 +1101,7 @@ class ProcessorService {
             }
         }
         else {
-            console.log('No match found');
+            debugLog('No match found');
         }
     }
     async filterValue(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
@@ -892,7 +1120,7 @@ class ProcessorService {
             }
             return resolvedArray.filter((item) => (0, processor_utils_1.compareValues)(item, operator, resolvedValue));
         }
-        console.log('No $Filter match found');
+        debugLog('No $Filter match found');
         return [];
     }
     async findValue(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
@@ -911,7 +1139,7 @@ class ProcessorService {
             }
             return resolvedArray.find((item) => (0, processor_utils_1.compareValues)(item, operator, resolvedValue));
         }
-        console.log('No $Find match found');
+        debugLog('No $Find match found');
         return null;
     }
     async splitValues(value, app, additional_logs, sample = [], index = {}, key = '', loopIndex = null) {
@@ -926,7 +1154,7 @@ class ProcessorService {
             return resolvedString.split(separator);
         }
         else {
-            console.log('No match found');
+            debugLog('No match found');
             return [];
         }
     }
@@ -947,7 +1175,7 @@ class ProcessorService {
             return mergedArray;
         }
         else {
-            console.log('No match found');
+            debugLog('No match found');
         }
     }
     async generateInputValue(input, stages) {
@@ -1071,7 +1299,7 @@ class ProcessorService {
     }
     async generateAuthValue(stages, app, sample, additional_logs) {
         try {
-            console.log('Generate Auth Data', { stages, app, sample });
+            debugLog('Generate Auth Data', { stages, app, sample });
             let auth_data = await this.fetchAuthData(app, additional_logs); //TODO: should use stages[0]
             // take the app tag in index 0..
             if (!auth_data) {
@@ -1098,7 +1326,7 @@ class ProcessorService {
             if (!env.auth) {
                 throw new Error(`App ${app_tag} in auth needs to have a definition for auth in env: ${this.processEnv.slug}`);
             }
-            console.log('Envroment', env.auth);
+            debugLog('Envroment', env.auth);
             let values = env.auth.values;
             if (!values) {
                 // no auth values
@@ -1106,7 +1334,7 @@ class ProcessorService {
             }
             if (!env.auth.expiry || (env.auth.expiry && Date.now() > new Date(env.auth.expiry).getTime())) {
                 // refresh
-                console.log('REFRESH DATA', env, app_tag);
+                debugLog('REFRESH DATA', env, app_tag);
                 values = await this.getAndStoreAuth(env, app_tag);
             }
             const decrypted = (0, processor_utils_1.decrypt)(values, this.productBuilderService.fetchPrivateKey());
@@ -1219,12 +1447,68 @@ class ProcessorService {
         }
     }
     async runJobs(job, additional_logs = {}) {
-        var _a;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
         const jobId = (_a = job.data) === null || _a === void 0 ? void 0 : _a._job_id;
         const jobType = job.name;
+        const startedAt = Date.now();
+        const eventStr = ((_c = (_b = job.data) === null || _b === void 0 ? void 0 : _b.event) !== null && _c !== void 0 ? _c : job.event);
+        const eventParts = typeof eventStr === 'string' ? eventStr.split(':') : [];
+        const jobParentTag = (_e = (_d = eventParts[0]) !== null && _d !== void 0 ? _d : eventStr) !== null && _e !== void 0 ? _e : undefined;
+        const jobChildTag = eventParts.length >= 2 ? eventParts.slice(1).join(':') : undefined;
+        // Resolve product and ensure logService is initialized so job lifecycle is always logged
+        const productTag = (_f = job.data) === null || _f === void 0 ? void 0 : _f.product;
+        if (productTag && this.workspace_id) {
+            try {
+                await this.productBuilderService.initializeProductByTag(productTag);
+                this.productId = this.productBuilderService.fetchProductId();
+                if (this.productId && !this.logService) {
+                    this.logService = new logs_service_1.default({
+                        product_id: this.productId,
+                        workspace_id: this.workspace_id,
+                        public_key: this.public_key,
+                        user_id: this.user_id,
+                        token: this.token,
+                        env_type: this.environment,
+                    });
+                }
+                if (this.logService) {
+                    this.logService.add({
+                        product_tag: productTag,
+                        product_id: this.productId,
+                        workspace_id: this.workspace_id,
+                        env: (_h = (_g = job.data) === null || _g === void 0 ? void 0 : _g.env) !== null && _h !== void 0 ? _h : '',
+                        process_id: jobId !== null && jobId !== void 0 ? jobId : (0, processor_utils_1.generateObjectId)(),
+                        type: types_1.LogEventTypes.JOB,
+                        parent_tag: jobParentTag,
+                        child_tag: jobChildTag,
+                        message: 'Job picked up for execution',
+                        data: {
+                            job_id: jobId,
+                            job_type: jobType,
+                            event: (_j = job.data) === null || _j === void 0 ? void 0 : _j.event,
+                            env: (_k = job.data) === null || _k === void 0 ? void 0 : _k.env,
+                        },
+                        status: types_1.LogEventStatus.PROCESSING,
+                        start: startedAt,
+                    });
+                }
+            }
+            catch (e) {
+                // Non-fatal: continue without job-level logging if product init fails
+            }
+        }
         // Update job status to running
         if (jobId && this.redisClient) {
-            await this.updateJobStatus(jobId, 'running', { started_at: Date.now() });
+            await this.updateJobStatus(jobId, 'running', { started_at: startedAt });
+        }
+        // Fire-and-forget: record running phase (do not await)
+        if (jobId && this.workspace_id) {
+            const auth = Object.assign(Object.assign({}, this.getUserAccess()), { access_key: this.accessKey });
+            if (!this.accessKey)
+                console.warn('[runJobs] Updating job execution phase (running) without access_key', { jobId });
+            void this.processorApiService
+                .updateJobExecutionPhase({ workspace_id: this.workspace_id, job_id: jobId, phase: 'running', started_at: startedAt }, auth)
+                .catch((err) => console.error('[runJobs] job execution phase running failed', { jobId, error: err }));
         }
         try {
             let result;
@@ -1260,56 +1544,193 @@ class ProcessorService {
             else {
                 throw new Error(`Unknown job type: ${jobType}`);
             }
+            const completedAt = Date.now();
+            const durationMs = completedAt - startedAt;
             // Update job status to completed
             if (jobId && this.redisClient) {
                 await this.updateJobStatus(jobId, 'completed', {
-                    completed_at: Date.now(),
+                    completed_at: completedAt,
                     result,
                 });
             }
+            // Fire-and-forget: record completed phase (do not await)
+            if (jobId && this.workspace_id) {
+                const auth = Object.assign(Object.assign({}, this.getUserAccess()), { access_key: this.accessKey });
+                if (!this.accessKey)
+                    console.warn('[runJobs] Updating job execution phase (completed) without access_key', { jobId });
+                const operation = typeof job.event === 'string' && job.event.includes(':')
+                    ? job.event.split(':').pop()
+                    : (_l = job.event) !== null && _l !== void 0 ? _l : undefined;
+                const outputPayload = result != null
+                    ? typeof result === 'object' && result !== null && !Array.isArray(result)
+                        ? result
+                        : { value: result }
+                    : undefined;
+                void this.processorApiService
+                    .updateJobExecutionPhase({
+                    workspace_id: this.workspace_id,
+                    job_id: jobId,
+                    phase: 'completed',
+                    completed_at: completedAt,
+                    duration_ms: durationMs,
+                    result_metadata: result != null ? { result: typeof result === 'object' ? result : { value: result } } : undefined,
+                    output: outputPayload,
+                    operation,
+                }, auth)
+                    .catch((err) => console.error('[runJobs] job execution phase completed failed', { jobId, error: err }));
+            }
+            // Log job execution completed so it shows in logs
+            if (this.logService) {
+                this.logService.add({
+                    product_tag: (_m = this.productTag) !== null && _m !== void 0 ? _m : (_o = job.data) === null || _o === void 0 ? void 0 : _o.product,
+                    product_id: this.productId,
+                    workspace_id: this.workspace_id,
+                    env: (_q = (_p = job.data) === null || _p === void 0 ? void 0 : _p.env) !== null && _q !== void 0 ? _q : '',
+                    process_id: jobId !== null && jobId !== void 0 ? jobId : this.process_id,
+                    type: types_1.LogEventTypes.JOB,
+                    parent_tag: jobParentTag,
+                    child_tag: jobChildTag,
+                    message: 'Job execution completed',
+                    data: { job_id: jobId, job_type: jobType, duration_ms: durationMs, result },
+                    status: types_1.LogEventStatus.SUCCESS,
+                    start: startedAt,
+                    end: completedAt,
+                });
+                await this.logService.publish();
+            }
             return result;
         }
         catch (error) {
-            // Update job status to failed or schedule retry
-            if (jobId && this.redisClient) {
-                const jobData = await this.getJobData(jobId);
-                if (jobData) {
-                    const { shouldRetry, delay } = this.calculateJobRetry(jobData, error.code);
-                    if (shouldRetry) {
-                        await this.updateJobStatus(jobId, 'scheduled', {
-                            retry_count: (jobData.retry_count || 0) + 1,
-                            last_error: error.message,
-                            last_error_code: error.code,
-                            scheduled_at: Date.now() + delay,
-                        });
-                        // Re-queue the job with delay
-                        await this.queues.jobs.add(jobType, job.data, {
-                            jobId: `${jobId}_retry_${jobData.retry_count + 1}`,
-                            delay,
-                        });
-                    }
-                    else {
-                        await this.updateJobStatus(jobId, 'failed', {
-                            completed_at: Date.now(),
-                            last_error: error.message,
-                            last_error_code: error.code,
-                        });
+            const failedAt = Date.now();
+            const jobData = jobId && this.redisClient ? await this.getJobData(jobId) : null;
+            // Update job status to failed or schedule retry (when we have Redis job data)
+            if (jobId && this.redisClient && jobData) {
+                const { shouldRetry, delay } = this.calculateJobRetry(jobData, error.code);
+                if (shouldRetry) {
+                    const retryCount = (jobData.retry_count || 0) + 1;
+                    await this.updateJobStatus(jobId, 'scheduled', {
+                        retry_count: retryCount,
+                        last_error: error.message,
+                        last_error_code: error.code,
+                        scheduled_at: Date.now() + delay,
+                    });
+                    // Fire-and-forget: record retry_scheduled phase (do not await)
+                    if (jobId && this.workspace_id) {
+                        const auth = Object.assign(Object.assign({}, this.getUserAccess()), { access_key: this.accessKey });
+                        if (!this.accessKey) {
+                            console.warn('[runJobs] Updating job execution phase without access_key — backend may return 401', { jobId, phase: 'retry_scheduled' });
+                        }
+                        void this.processorApiService
+                            .updateJobExecutionPhase({
+                            workspace_id: this.workspace_id,
+                            job_id: jobId,
+                            phase: 'retry_scheduled',
+                            error: error.message,
+                            error_code: error === null || error === void 0 ? void 0 : error.code,
+                            retry_count: retryCount,
+                        }, auth)
+                            .catch((err) => console.error('[runJobs] job execution phase retry_scheduled failed', { jobId, error: err }));
                     }
-                    // Add to execution history
-                    await this.addJobExecution(jobId, {
-                        number: (jobData.execution_count || 0) + 1,
-                        started_at: jobData.started_at || Date.now(),
-                        completed_at: Date.now(),
-                        duration_ms: Date.now() - (jobData.started_at || Date.now()),
-                        status: 'failed',
-                        error: error.message,
-                        error_code: error.code,
+                    // Re-queue the job with delay
+                    await this.queues.jobs.add(jobType, job.data, {
+                        jobId: `${jobId}_retry_${jobData.retry_count + 1}`,
+                        delay,
                     });
                 }
+                else {
+                    await this.updateJobStatus(jobId, 'failed', {
+                        completed_at: failedAt,
+                        last_error: error.message,
+                        last_error_code: error.code,
+                    });
+                }
+                // Add to execution history
+                await this.addJobExecution(jobId, {
+                    number: (jobData.execution_count || 0) + 1,
+                    started_at: jobData.started_at || Date.now(),
+                    completed_at: Date.now(),
+                    duration_ms: Date.now() - (jobData.started_at || Date.now()),
+                    status: 'failed',
+                    error: error.message,
+                    error_code: error.code,
+                });
+            }
+            // Always record failed phase on JobExecutionTracker when we have jobId + workspace_id
+            // (even when Redis job data is missing, so failures are visible in the tracker)
+            if (jobId && this.workspace_id) {
+                const auth = Object.assign(Object.assign({}, this.getUserAccess()), { access_key: this.accessKey });
+                if (!this.accessKey) {
+                    console.warn('[runJobs] Updating job execution phase (failed) without access_key — backend may return 401', { jobId });
+                }
+                const durationMs = (jobData === null || jobData === void 0 ? void 0 : jobData.started_at) != null ? failedAt - jobData.started_at : failedAt - startedAt;
+                const operation = typeof job.event === 'string' && job.event.includes(':')
+                    ? job.event.split(':').pop()
+                    : (_r = job.event) !== null && _r !== void 0 ? _r : undefined;
+                void this.processorApiService
+                    .updateJobExecutionPhase({
+                    workspace_id: this.workspace_id,
+                    job_id: jobId,
+                    phase: 'failed',
+                    completed_at: failedAt,
+                    duration_ms: durationMs,
+                    error: (error === null || error === void 0 ? void 0 : error.message) != null ? String(error.message) : undefined,
+                    error_code: (error === null || error === void 0 ? void 0 : error.code) != null ? String(error.code) : undefined,
+                    operation,
+                }, auth)
+                    .catch((err) => console.error('[runJobs] job execution phase failed (tracker update)', { jobId, error: err }));
+            }
+            // Log job execution failed so it shows in logs
+            if (this.logService) {
+                this.logService.add({
+                    product_tag: (_s = this.productTag) !== null && _s !== void 0 ? _s : (_t = job.data) === null || _t === void 0 ? void 0 : _t.product,
+                    product_id: this.productId,
+                    workspace_id: this.workspace_id,
+                    env: (_v = (_u = job.data) === null || _u === void 0 ? void 0 : _u.env) !== null && _v !== void 0 ? _v : '',
+                    process_id: jobId !== null && jobId !== void 0 ? jobId : this.process_id,
+                    type: types_1.LogEventTypes.JOB,
+                    parent_tag: jobParentTag,
+                    child_tag: jobChildTag,
+                    message: 'Job execution failed',
+                    data: {
+                        job_id: jobId,
+                        job_type: jobType,
+                        error: (error === null || error === void 0 ? void 0 : error.message) != null ? String(error.message) : undefined,
+                        error_code: (error === null || error === void 0 ? void 0 : error.code) != null ? String(error.code) : undefined,
+                    },
+                    status: types_1.LogEventStatus.FAIL,
+                    start: startedAt,
+                    end: failedAt,
+                });
+                await this.logService.publish();
             }
             throw error;
         }
     }
+    /**
+     * Record a failed phase on the job execution tracker (e.g. from BullMQ 'failed' handler).
+     * Call when the worker job fails so the tracker is updated even if runJobs' catch didn't run.
+     */
+    async recordJobExecutionPhaseFailed(jobId, errorMessage, errorCode) {
+        if (!jobId || !this.workspace_id)
+            return;
+        const auth = Object.assign(Object.assign({}, this.getUserAccess()), { access_key: this.accessKey });
+        if (!this.accessKey)
+            console.warn('[recordJobExecutionPhaseFailed] No access_key — backend may return 401', { jobId });
+        const failedAt = Date.now();
+        try {
+            await this.processorApiService.updateJobExecutionPhase({
+                workspace_id: this.workspace_id,
+                job_id: jobId,
+                phase: 'failed',
+                completed_at: failedAt,
+                error: errorMessage,
+                error_code: errorCode,
+            }, auth);
+        }
+        catch (err) {
+            console.error('[recordJobExecutionPhaseFailed] tracker update failed', { jobId, error: err });
+        }
+    }
     /**
      * Get job data from Redis
      */
@@ -1785,7 +2206,7 @@ class ProcessorService {
             const payload = JSON.parse((0, processor_utils_1.decrypt)(String(appEnv.auth.data), this.productBuilderService.fetchPrivateKey()));
             let app = await this.fetchThirdPartyApp(access_tag);
             const auth = app.auths.find((item) => item.tag === appEnv.auth.auth_tag);
-            console.log('JAMESY', auth);
+            debugLog('JAMESY', auth);
             if (!auth) {
                 // throw an error
                 throw new Error(`Cannot find auth ${appEnv.auth.auth_tag} on environment ${appEnv.product_env_slug}`);
@@ -1806,7 +2227,7 @@ class ProcessorService {
                         request_base_url = env.base_url;
                     }
                 }
-                console.log('payloadabi!!!!', payload);
+                debugLog('payloadabi!!!!', payload);
                 const results = await this.sendActionRequest(request_base_url, url, payload, method, appEnv.app_env_slug);
                 const values = (0, processor_utils_1.encrypt)(JSON.stringify(results), this.productBuilderService.fetchPrivateKey());
                 const productApp = await this.productBuilderService.fetchApp(access_tag);
@@ -1980,7 +2401,8 @@ class ProcessorService {
             let payloads;
             let result;
             //const product = this.productBuilderService.fetchProduct();
-            if (cache_tag && this.redisClient) {
+            // Check cache for existing result (skip if early cache check already done)
+            if (cache_tag && this.redisClient && !event.skipCacheFetch) {
                 const productCache = await this.productBuilderService.fetchCache(cache_tag);
                 if (!productCache) {
                     throw new Error('Invalid cache tag ');
@@ -2024,7 +2446,8 @@ class ProcessorService {
                     throw new Error('Invalid cache tag ');
                 }
                 const inputString = JSON.stringify(event.input);
-                await this.addToCache({
+                // Fire-and-forget cache store
+                this.addToCache({
                     input: inputString,
                     privateKey: this.productBuilderService.fetchPrivateKey(),
                     data: JSON.stringify(result),
@@ -2079,7 +2502,7 @@ class ProcessorService {
             this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Process http request - failed', failed_execution: true, data: { e: error, input: (0, processor_utils_1.anonymizeObject)(payloads) }, status: types_1.LogEventStatus.FAIL, app_id, action: event.event, start,
                 end }));
             try {
-                console.log(e);
+                debugLog(e);
                 const value = await this.addToFailureOutput(e, event, {
                     request_base_url,
                     resource,
@@ -2305,7 +2728,7 @@ class ProcessorService {
                 timeout: 15000,
                 withCredentials: false,
             };
-            console.log('REQUEST!!!!', request);
+            debugLog('REQUEST!!!!', request);
             const response = await axios_1.default.request(request);
             return response.data;
         }
@@ -2316,7 +2739,10 @@ class ProcessorService {
     }
     async processStorage(action) {
         //TODO: schema validation
-        const { env, input, retries, event, product: product_tag, session, cache } = action;
+        var _a, _b, _c, _d, _e, _f, _g;
+        const { env, input, retries, event, product: product_tag, session, cache, preloadedBootstrap } = action;
+        // event is "storage_tag:operation" (e.g. gcp-storage:upload); backend looks up storage by tag only
+        const storageTag = event.includes(':') ? event.split(':')[0] : event;
         const additional_logs = {
             parent_tag: event,
             type: types_1.LogEventTypes.STORAGE,
@@ -2337,19 +2763,26 @@ class ProcessorService {
             const process_id = (0, processor_utils_1.generateObjectId)();
             this.baseLogs = Object.assign({ product_tag: this.productTag, product_id: this.productId, workspace_id: this.workspace_id, env,
                 process_id, data: this.clone }, additional_logs);
-            // Single bootstrap call to fetch all storage data
-            const bootstrapData = await this.productBuilderService.bootstrapStorage({
-                product_tag,
-                env_slug: env,
-                storage_tag: event,
-            });
+            // Use preloaded bootstrap when provided (e.g. workflow batch prefetch), otherwise fetch
+            const bootstrapData = preloadedBootstrap
+                ? preloadedBootstrap
+                : await this.productBuilderService.bootstrapStorage({
+                    product_tag,
+                    env_slug: env,
+                    storage_tag: storageTag,
+                });
             // Initialize from bootstrap data
             this.productId = bootstrapData.product_id;
             this.processEnv = bootstrapData.env;
             // Process session if provided - verify and resolve $Session{} references
             if (session && bootstrapData.private_key) {
                 const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../../sessions')));
-                const sessionResult = await processSessionForExecution(session, bootstrapData.private_key, input, env);
+                const sessionResult = await processSessionForExecution(session, bootstrapData.private_key, input, env, {
+                    fetchSessionSelector: async (sessionTag) => {
+                        const sessionConfig = await this.productBuilderService.fetchSession(sessionTag);
+                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
+                    },
+                });
                 if (sessionResult.error) {
                     throw new Error(`Session validation failed: ${sessionResult.error}`);
                 }
@@ -2387,18 +2820,30 @@ class ProcessorService {
             const result = await this.runStorage(payload, additional_logs, {
                 storage: bootstrapData.storage,
                 storage_env: bootstrapData.storage_env,
+                private_key: bootstrapData.private_key,
             });
             this.end = Date.now();
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Storing file - success', data: { input: this.clone, result }, status: types_1.LogEventStatus.SUCCESS }));
-            await this.writeResult(types_1.LogEventStatus.SUCCESS);
-            await this.logService.publish();
-            return Object.assign(Object.assign({}, result), { process_id: this.process_id });
+            if (this.logService) {
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Storing file - success', data: { input: this.clone, result }, status: types_1.LogEventStatus.SUCCESS }));
+                await this.writeResult(types_1.LogEventStatus.SUCCESS);
+                await this.logService.publish();
+            }
+            return { process_id: this.process_id, output: result !== null && result !== void 0 ? result : {} };
         }
         catch (e) {
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Storing file - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            const err = e;
+            const apiReason = (_b = (_a = err === null || err === void 0 ? void 0 : err.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.errors;
+            const reason = typeof apiReason === 'string'
+                ? apiReason
+                : (_g = (_f = (_c = apiReason === null || apiReason === void 0 ? void 0 : apiReason.message) !== null && _c !== void 0 ? _c : (_e = (_d = err === null || err === void 0 ? void 0 : err.response) === null || _d === void 0 ? void 0 : _d.data) === null || _e === void 0 ? void 0 : _e.message) !== null && _f !== void 0 ? _f : err === null || err === void 0 ? void 0 : err.message) !== null && _g !== void 0 ? _g : String(e);
+            const message = `Storing file - failed: ${reason}`;
             this.end = Date.now();
-            await this.logService.publish();
-            return { process_id: this.process_id };
+            if (this.logService) {
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message, data: { e, reason }, status: types_1.LogEventStatus.FAIL }));
+                await this.logService.publish();
+            }
+            // Rethrow so the workflow step is marked failed and the executor can persist the error reason
+            throw e;
         }
     }
     async processMessageBrokerSubscribe(data) {
@@ -2451,6 +2896,7 @@ class ProcessorService {
         }
     }
     async processMessageBrokerPublish(data) {
+        var _a, _b, _c, _d;
         const [brokerTag, topicTag] = data.event.split(':');
         if (!brokerTag || !topicTag) {
             throw new Error(`message broker events should be in the format broker_tag:event_tag`);
@@ -2477,11 +2923,26 @@ class ProcessorService {
             await this.intializeProduct(additional_logs);
             this.baseLogs.product_id = this.productId;
             this.process_id = process_id;
+            if (!this.logService) {
+                this.logService = new logs_service_1.default({
+                    product_id: this.productId,
+                    workspace_id: this.workspace_id,
+                    public_key: this.public_key,
+                    user_id: this.user_id,
+                    token: this.token,
+                    env_type: this.environment,
+                });
+            }
             // Process session if provided - verify and resolve $Session{} references
             const privateKey = this.productBuilderService.fetchPrivateKey();
             if (data.session && privateKey) {
                 const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../../sessions')));
-                const sessionResult = await processSessionForExecution(data.session, privateKey, data.input, data.env);
+                const sessionResult = await processSessionForExecution(data.session, privateKey, data.input, data.env, {
+                    fetchSessionSelector: async (sessionTag) => {
+                        const sessionConfig = await this.productBuilderService.fetchSession(sessionTag);
+                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
+                    },
+                });
                 if (sessionResult.error) {
                     throw new Error(`Session validation failed: ${sessionResult.error}`);
                 }
@@ -2506,24 +2967,47 @@ class ProcessorService {
             };
             const result = await this.runBrokerPublish(payload);
             this.end = Date.now();
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Publishing to topic - success', data: { input: (0, processor_utils_1.anonymizeObject)(this.clone), result }, status: types_1.LogEventStatus.SUCCESS }));
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Produce to topic - success', data: { input: (0, processor_utils_1.anonymizeObject)(this.clone), result: (0, processor_utils_1.anonymizeObject)(result !== null && result !== void 0 ? result : {}) }, status: types_1.LogEventStatus.SUCCESS }));
             await this.writeResult(types_1.LogEventStatus.SUCCESS);
-            await this.logService.publish();
-            return result;
+            // Fire-and-forget so step latency isn't dominated by log upload (20–50x slower otherwise)
+            this.logService.publish().catch(() => { });
+            return { process_id: this.process_id, output: Object.assign(Object.assign({}, (result !== null && result !== void 0 ? result : {})), { published: true }) };
         }
         catch (e) {
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Publishing to topic - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            const err = e;
+            const apiReason = (_b = (_a = err === null || err === void 0 ? void 0 : err.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.errors;
+            const reason = typeof apiReason === 'string'
+                ? apiReason
+                : (_d = (_c = apiReason === null || apiReason === void 0 ? void 0 : apiReason.message) !== null && _c !== void 0 ? _c : err === null || err === void 0 ? void 0 : err.message) !== null && _d !== void 0 ? _d : String(e);
+            const message = `Publishing to topic - failed: ${reason}`;
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message, data: { e, reason }, status: types_1.LogEventStatus.FAIL }));
             this.end = Date.now();
             await this.logService.publish();
-            return { process_id: this.process_id };
+            // Rethrow so the workflow step is marked failed and the executor can persist the error reason
+            throw e;
         }
     }
     async processJob(job, additional_logs = {}) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        await this.productBuilderService.initializeProductByTag(job.product);
+        const productId = this.productBuilderService.fetchProductId();
+        if (productId)
+            this.productId = productId;
         const productJob = await this.productBuilderService.fetchJob(job.event);
         if (!productJob) {
             throw new Error(`Job ${job.event} not found`);
         }
+        // Ensure logService exists so dispatch event is logged
+        if (!this.logService && this.productId && this.workspace_id) {
+            this.logService = new logs_service_1.default({
+                product_id: this.productId,
+                workspace_id: this.workspace_id,
+                public_key: this.public_key,
+                user_id: this.user_id,
+                token: this.token,
+                env_type: this.environment,
+            });
+        }
         await this.validateActionDataMappingInput(job.input, productJob.type);
         const NOW = Date.now();
         // Treat anything above Jan 1, 2023 as a timestamp (to be safe and future-proof)
@@ -2745,15 +3229,79 @@ class ProcessorService {
         // Add job input with the job ID for tracking
         jobInput._job_id = jobId;
         // Add job to queue
+        if (!((_j = this.queues) === null || _j === void 0 ? void 0 : _j.jobs)) {
+            throw new Error('Queues not configured. dispatch() requires a queue connection.');
+        }
         await this.queues.jobs.add(productJob.type, jobInput, options);
+        // Record job execution in integrations (so jobexecutiontrackers table is populated)
+        if (this.workspace_id && this.productId) {
+            const auth = Object.assign(Object.assign({}, this.getUserAccess()), { access_key: this.accessKey });
+            if (!this.accessKey) {
+                console.warn('[processJob] Creating job execution without access_key — backend may return 401', { jobId });
+            }
+            const operation = typeof job.event === 'string' && job.event.includes(':')
+                ? job.event.split(':').pop()
+                : (_k = job.event) !== null && _k !== void 0 ? _k : undefined;
+            void this.processorApiService
+                .createJobExecution({
+                job_id: jobId,
+                workspace_id: this.workspace_id,
+                product_id: this.productId,
+                product_tag: job.product,
+                env: job.env,
+                job_tag: job.event,
+                job_type: productJob.type,
+                phase: delay > 0 ? 'scheduled' : 'queued',
+                scheduled_at: delay > 0 ? scheduled_at : undefined,
+                triggered_by: job.triggered_by,
+                input: job.input != null && typeof job.input === 'object'
+                    ? (0, processor_utils_1.truncateInputForApi)(job.input)
+                    : undefined,
+                operation,
+            }, auth)
+                .catch((err) => console.error('[processJob] job execution create failed', { jobId, error: err }));
+        }
+        else {
+            const missing = [];
+            if (!this.workspace_id)
+                missing.push('workspace_id');
+            if (!this.productId)
+                missing.push('productId');
+            console.warn('[processJob] Skipping job execution create — missing:', missing.join(', '), { jobId });
+        }
+        // Log dispatch event so it shows in logs
+        const dispatchStatus = delay > 0 ? 'scheduled' : 'queued';
+        if (this.logService) {
+            this.logService.add({
+                product_tag: job.product,
+                product_id: this.productId,
+                workspace_id: this.workspace_id,
+                env: job.env,
+                process_id: jobId,
+                type: types_1.LogEventTypes.JOB,
+                message: 'Job dispatched',
+                data: {
+                    job_id: jobId,
+                    job_type: productJob.type,
+                    event: job.event,
+                    status: dispatchStatus,
+                    scheduled_at,
+                    recurring: isRecurring,
+                    next_run_at,
+                },
+                status: types_1.LogEventStatus.SUCCESS,
+            });
+            await this.logService.publish();
+        }
         return {
             job_id: jobId,
-            status: delay > 0 ? 'scheduled' : 'queued',
+            status: dispatchStatus,
             scheduled_at,
             recurring: isRecurring,
             next_run_at,
         };
     }
+    /** Expo: expoClient() is already a module-level singleton (one axios instance), so no per-run pool needed. */
     async sendExpoNotification(payload, device_tokens) {
         const message = {
             to: device_tokens,
@@ -2778,12 +3326,8 @@ class ProcessorService {
             tokens: device_tokens,
         };
         try {
-            const admin = require('firebase-admin');
-            const serviceAccount = credentials;
-            admin.initializeApp({
-                credential: admin.credential.cert(serviceAccount),
-            });
-            await admin.messaging().sendMulticast(message);
+            const app = await this.getFirebaseApp(credentials);
+            await app.messaging().sendEachForMulticast(message);
         }
         catch (e) {
             if (this.environment === types_1.EnvType.PRODUCTION) {
@@ -2791,49 +3335,73 @@ class ProcessorService {
             }
         }
     }
-    async ProcessExpoNotification(notification, template, payload, additional_logs) {
+    async ProcessExpoNotification(notification, template, payload, additional_logs, logType = types_1.LogEventTypes.PUSH) {
+        var _a, _b;
+        debugLog('[ProcessExpoNotification] ENTRY', { deviceTokens: (_a = payload === null || payload === void 0 ? void 0 : payload.device_tokens) === null || _a === void 0 ? void 0 : _a.length, logType });
         (0, processor_utils_1.validateNotification)(template, payload);
-        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Validate notification payload - success', data: {}, status: types_1.LogEventStatus.SUCCESS }));
+        debugLog('[ProcessExpoNotification] Validation passed');
         const { title, body, data } = (0, processor_utils_1.generateNotificationTemplate)(template, payload);
-        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Generate notification template - success', data: { title, body, data: (0, processor_utils_1.anonymizeObject)(data) }, status: types_1.LogEventStatus.SUCCESS }));
+        debugLog('[ProcessExpoNotification] Template generated', { title: (_b = title === null || title === void 0 ? void 0 : title.slice) === null || _b === void 0 ? void 0 : _b.call(title, 0, 40), bodyLength: body === null || body === void 0 ? void 0 : body.length });
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { type: logType, message: 'Generate notification template - success', data: { title, body, data }, status: types_1.LogEventStatus.SUCCESS }));
+        debugLog('[ProcessExpoNotification] Sending to Expo');
         await this.sendExpoNotification({ title, body, data }, payload.device_tokens);
-        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Send Expo notification - success', data: { title, body, data: (0, processor_utils_1.anonymizeObject)(data) }, status: types_1.LogEventStatus.SUCCESS }));
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { type: logType, message: 'Send Expo notification - success', data: { title, body, data }, status: types_1.LogEventStatus.SUCCESS }));
     }
-    async ProcessFirebaseNotification(notification, template, payload, additional_logs) {
+    async ProcessFirebaseNotification(notification, template, payload, additional_logs, logType = types_1.LogEventTypes.PUSH) {
+        var _a, _b;
+        debugLog('[ProcessFirebaseNotification] ENTRY', { deviceTokens: (_a = payload === null || payload === void 0 ? void 0 : payload.device_tokens) === null || _a === void 0 ? void 0 : _a.length, logType });
         (0, processor_utils_1.validateNotification)(template, payload);
-        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Validate Firebase notification payload - success', data: {}, status: types_1.LogEventStatus.SUCCESS }));
+        debugLog('[ProcessFirebaseNotification] Validation passed');
         const { title, body, data } = (0, processor_utils_1.generateNotificationTemplate)(template, payload);
-        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Generate Firebase notification template - success', data: { title, body: (0, processor_utils_1.anonymizeObject)(data), data: (0, processor_utils_1.anonymizeObject)(data) }, status: types_1.LogEventStatus.SUCCESS }));
+        debugLog('[ProcessFirebaseNotification] Template generated', { title: (_b = title === null || title === void 0 ? void 0 : title.slice) === null || _b === void 0 ? void 0 : _b.call(title, 0, 40), bodyLength: body === null || body === void 0 ? void 0 : body.length });
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { type: logType, message: 'Generate Firebase notification template - success', data: { title, body, data }, status: types_1.LogEventStatus.SUCCESS }));
+        debugLog('[ProcessFirebaseNotification] Sending to Firebase');
         await this.sendFirebaseNotification({ title, body, data }, payload.device_tokens, notification.credentials);
-        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Send Firebase notification - success', data: { title, body: (0, processor_utils_1.anonymizeObject)(data), data: (0, processor_utils_1.anonymizeObject)(data) }, status: types_1.LogEventStatus.SUCCESS }));
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { type: logType, message: 'Send Firebase notification - success', data: { title, body, data }, status: types_1.LogEventStatus.SUCCESS }));
     }
     async runNotification(notification, additional_logs, bootstrapData) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
         const { event } = notification;
         const input = notification.input;
+        const logMessageLog = (channelType, status, err) => {
+            if (!this.productId || !this.workspace_id || (bootstrapData === null || bootstrapData === void 0 ? void 0 : bootstrapData.product_tag) == null || (bootstrapData === null || bootstrapData === void 0 ? void 0 : bootstrapData.env) == null)
+                return;
+            this.fireAndForgetLogNotificationMessage(Object.assign({ workspace_id: this.workspace_id, product_id: this.productId, product_tag: bootstrapData.product_tag, env: bootstrapData.env, notification_tag: event, input: (input !== null && input !== void 0 ? input : {}), type: channelType, status, process_id: bootstrapData.process_id, retries: 0, session: bootstrapData.session, cache: bootstrapData.cache }, (status === 'failed' && err !== undefined && { error: err instanceof Error ? err.message : String(err) })));
+        };
+        debugLog('[runNotification] ENTRY', { event, env: (_a = notification.env) === null || _a === void 0 ? void 0 : _a.slug, hasBootstrap: !!bootstrapData, inputKeys: input ? Object.keys(input) : [] });
         try {
             let notificationEvent;
             let message;
             let envConfig;
             // Use bootstrap data if provided, otherwise fetch via API
             if (bootstrapData) {
+                debugLog('[runNotification] Using bootstrap data');
                 notificationEvent = bootstrapData.notification;
                 message = bootstrapData.message;
                 envConfig = bootstrapData.env_config;
             }
             else {
+                debugLog('[runNotification] Fetching notification via API');
                 // Fallback to original API-based fetching
                 notificationEvent = (await this.productBuilderService.fetchNotification(event.split(':')[0]));
                 message = await this.productBuilderService.fetchNotificationMessage(event);
                 if (!message) {
                     throw new Error(`Message ${event} not found`);
                 }
-                envConfig = (_a = notificationEvent.envs) === null || _a === void 0 ? void 0 : _a.find((data) => data.slug === notification.env.slug);
+                envConfig = (_b = notificationEvent.envs) === null || _b === void 0 ? void 0 : _b.find((data) => data.slug === notification.env.slug);
             }
             if (!envConfig) {
+                debugLog('[runNotification] ERROR: env config not found', { envSlug: (_c = notification.env) === null || _c === void 0 ? void 0 : _c.slug });
                 throw new Error(`Notification env config for ${notification.env.slug} not found`);
             }
             let { push_notifications: notifications, emails, callbacks, sms: smses, } = envConfig;
+            debugLog('[runNotification] Env config channels', {
+                hasPush: !!notifications,
+                pushType: notifications === null || notifications === void 0 ? void 0 : notifications.type,
+                hasEmails: !!emails,
+                hasCallbacks: !!callbacks,
+                hasSms: !!smses,
+            });
             // Resolve any $Secret{} references in notification configs
             const secretsService = (0, secrets_1.getSecretsService)();
             if (secretsService) {
@@ -2855,36 +3423,73 @@ class ProcessorService {
                 }
             }
             const { push_notification: push, email, callback, sms } = message;
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetching notification', data: notificationEvent, status: types_1.LogEventStatus.SUCCESS }));
-            if (push) {
+            debugLog('[runNotification] Message template flags', { push: !!push, email: !!email, callback: !!callback, sms: !!sms });
+            debugLog('[runNotification] Input channels present', {
+                push_notification: !!input.push_notification,
+                email: !!input.email,
+                callback: !!input.callback,
+                sms: !!input.sms,
+            });
+            if (!push && (input.push_notification || notifications)) {
+                debugLog('[runNotification] PUSH: skipped (message has no push template)', { hasInputPush: !!input.push_notification, hasNotifications: !!notifications });
+            }
+            if (push && !input.push_notification) {
+                debugLog('[runNotification] PUSH: skipped (no input.push_notification)');
+            }
+            if (push && input.push_notification) {
+                debugLog('[runNotification] PUSH: resolving title/body/data');
                 input.push_notification.title = (0, processor_utils_1.replacePlaceholderString)(push.title, input.push_notification.title || {});
                 input.push_notification.body = await this.generatePayload(input.push_notification.body || {}, notification, additional_logs, message.push_notification_data.filter((data) => data.parent_key === 'body') || []);
                 input.push_notification.data = await this.generatePayload(input.push_notification.data || {}, notification, additional_logs, message.push_notification_data.filter((data) => data.parent_key === 'data') || []);
             }
-            const validationPayload = (await this.inputService.parseJson({
-                data: Object.assign(Object.assign({}, input.push_notification.title), input.push_notification.body),
-                expected: types_1.ExpectedValues.PARSEINPUT,
-            }));
-            //await this.inputService.validateInput(validationPayload, message.push_notification_data, "Push Notifications");
-            if (push && notifications.type === types_1.Notifiers.EXPO) {
+            if (push && input.push_notification) {
+                const validationPayload = (await this.inputService.parseJson({
+                    data: Object.assign(Object.assign({}, input.push_notification.title), input.push_notification.body),
+                    expected: types_1.ExpectedValues.PARSEINPUT,
+                }));
+                //await this.inputService.validateInput(validationPayload, message.push_notification_data, "Push Notifications");
+            }
+            if (push && input.push_notification && (notifications === null || notifications === void 0 ? void 0 : notifications.type) !== types_1.Notifiers.EXPO && (notifications === null || notifications === void 0 ? void 0 : notifications.type) !== types_1.Notifiers.FIREBASE) {
+                debugLog('[runNotification] PUSH: skipped (not Expo or Firebase)', { notificationsType: notifications === null || notifications === void 0 ? void 0 : notifications.type });
+                this.lastNotificationFailureType = types_1.LogEventTypes.PUSH;
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { type: types_1.LogEventTypes.PUSH, message: 'Push skipped - no Expo or Firebase provider configured', data: { push_type: notifications === null || notifications === void 0 ? void 0 : notifications.type }, status: types_1.LogEventStatus.SUCCESS }));
+            }
+            if (push && input.push_notification && (notifications === null || notifications === void 0 ? void 0 : notifications.type) === types_1.Notifiers.EXPO) {
+                debugLog('[runNotification] PUSH: processing Expo');
+                this.lastNotificationFailureType = types_1.LogEventTypes.PUSH;
                 try {
                     await this.ProcessExpoNotification(notifications, message, input.push_notification, additional_logs);
-                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { successful_execution: true, message: 'Processing Expo notification - success', data: {}, status: types_1.LogEventStatus.SUCCESS }));
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { type: types_1.LogEventTypes.PUSH, successful_execution: true, message: 'Processing Expo notification - success', data: {}, status: types_1.LogEventStatus.SUCCESS }));
+                    logMessageLog('push', 'sent');
+                    debugLog('[runNotification] PUSH (Expo): success');
                 }
                 catch (e) {
-                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message: 'Processing Expo notification - failed', data: {}, status: types_1.LogEventStatus.SUCCESS }));
+                    debugLog('[runNotification] PUSH (Expo): failed', e);
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { type: types_1.LogEventTypes.PUSH, failed_execution: true, message: 'Processing Expo notification - failed', data: {}, status: types_1.LogEventStatus.FAIL }));
+                    logMessageLog('push', 'failed', e);
                 }
             }
-            if (push && notifications.type === types_1.Notifiers.FIREBASE) {
+            if (push && input.push_notification && (notifications === null || notifications === void 0 ? void 0 : notifications.type) === types_1.Notifiers.FIREBASE) {
+                debugLog('[runNotification] PUSH: processing Firebase');
+                this.lastNotificationFailureType = types_1.LogEventTypes.PUSH;
                 try {
                     await this.ProcessFirebaseNotification(notifications, message, input.push_notification, additional_logs);
-                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { successful_execution: true, message: 'Processing Firebase notification - success', data: { notification, input: (0, processor_utils_1.anonymizeObject)(input.push_notification) }, status: types_1.LogEventStatus.SUCCESS }));
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { type: types_1.LogEventTypes.PUSH, successful_execution: true, message: 'Processing Firebase notification - success', data: { notification }, status: types_1.LogEventStatus.SUCCESS }));
+                    logMessageLog('push', 'sent');
+                    debugLog('[runNotification] PUSH (Firebase): success');
                 }
                 catch (e) {
-                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message: 'Processing Firebase notification - failed', data: { notification, input: (0, processor_utils_1.anonymizeObject)(input.push_notification) }, status: types_1.LogEventStatus.FAIL }));
+                    debugLog('[runNotification] PUSH (Firebase): failed', e);
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { type: types_1.LogEventTypes.PUSH, failed_execution: true, message: 'Processing Firebase notification - failed', data: { notification, input: input.push_notification }, status: types_1.LogEventStatus.FAIL }));
+                    logMessageLog('push', 'failed', e);
                 }
             }
-            if (email && emails) {
+            if (email && emails && !input.email) {
+                debugLog('[runNotification] EMAIL: skipped (no input.email)');
+            }
+            if (email && emails && input.email) {
+                debugLog('[runNotification] EMAIL: processing (subject, template, recipients)');
+                this.lastNotificationFailureType = types_1.LogEventTypes.EMAIL;
                 input.email.subject = await this.generatePayload(input.email.subject, notification, additional_logs, message.email_data.filter((data) => data.parent_key === 'subject'));
                 input.email.template = await this.generatePayload(input.email.template, notification, additional_logs, message.email_data.filter((data) => data.parent_key === 'template'));
                 input.email.recipients = await Promise.all(input.email.recipients.map(async (email) => await this.generateStringValues(email, notification.event, additional_logs)));
@@ -2895,14 +3500,13 @@ class ProcessorService {
                 //await this.inputService.validateInput(validationPayload, message.email_data);
                 input.email.recipients.map((email) => this.inputService.validateEmailString({ key: 'to', value: email }));
                 const { sender_email: from } = emails, auth = __rest(emails, ["sender_email"]);
-                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Attempt email auth fetch - success', data: { from: (0, processor_utils_1.anonymizeValue)(from), host: (0, processor_utils_1.anonymizeValue)(auth.host), port: (0, processor_utils_1.anonymizeValue)(auth.port) }, status: types_1.LogEventStatus.SUCCESS }));
                 const templateMaker = (0, handlebars_1.compile)(email.template);
                 const template = templateMaker(input.email.template);
                 const subject = (0, processor_utils_1.replacePlaceholderString)(email.subject, input.email.subject || {});
-                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Generate email template - success', data: {
-                        template: (0, processor_utils_1.anonymizeValue)(template),
-                        subject: (0, processor_utils_1.anonymizeValue)(subject),
-                        input: (0, processor_utils_1.anonymizeObject)(input.email),
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { type: types_1.LogEventTypes.EMAIL, message: 'Generate email template - success', data: {
+                        template,
+                        subject,
+                        input: input.email,
                     }, status: types_1.LogEventStatus.SUCCESS }));
                 const mailOptions = {
                     from,
@@ -2910,57 +3514,115 @@ class ProcessorService {
                     subject,
                     template,
                 };
+                debugLog('[runNotification] EMAIL: sending mail', { to: (_d = mailOptions.to) === null || _d === void 0 ? void 0 : _d.length, subject: (_f = (_e = mailOptions.subject) === null || _e === void 0 ? void 0 : _e.slice) === null || _f === void 0 ? void 0 : _f.call(_e, 0, 50) });
                 try {
-                    const transporter = await (0, processor_utils_1.mailerClient)(auth);
-                    const response = await transporter.sendMail(mailOptions);
-                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Send email - success', successful_execution: true, data: { response }, status: types_1.LogEventStatus.SUCCESS }));
+                    const transporter = await this.getMailTransporter(auth);
+                    await transporter.sendMail(mailOptions);
+                    logMessageLog('email', 'sent');
                 }
                 catch (e) {
-                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message: 'Send email - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+                    debugLog('[runNotification] EMAIL: send failed', e);
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { type: types_1.LogEventTypes.EMAIL, failed_execution: true, message: 'Send email - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+                    logMessageLog('email', 'failed', e);
                 }
             }
-            if (callback && callbacks) {
+            if (callback && !callbacks) {
+                debugLog('[runNotification] CALLBACK: skipped (no callback config in env)');
+                this.lastNotificationFailureType = types_1.LogEventTypes.CALLBACKS;
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { type: types_1.LogEventTypes.CALLBACKS, message: 'Callback skipped - no callback config in env', data: {}, status: types_1.LogEventStatus.SUCCESS }));
+            }
+            if (callback && callbacks && !input.callback) {
+                debugLog('[runNotification] CALLBACK: skipped (no input.callback)');
+            }
+            if (callback && callbacks && input.callback) {
+                debugLog('[runNotification] CALLBACK: processing', { url: callbacks.url, method: callbacks.method });
+                this.lastNotificationFailureType = types_1.LogEventTypes.CALLBACKS;
                 const payload = {
-                    query: Object.assign(Object.assign({}, (_b = input.callback) === null || _b === void 0 ? void 0 : _b.query), (_c = callbacks.auth) === null || _c === void 0 ? void 0 : _c.query),
-                    headers: Object.assign(Object.assign({}, (_d = input.callback) === null || _d === void 0 ? void 0 : _d.headers), (_e = callbacks.auth) === null || _e === void 0 ? void 0 : _e.headers),
-                    params: Object.assign(Object.assign({}, (_f = input.callback) === null || _f === void 0 ? void 0 : _f.params), (_g = callbacks.auth) === null || _g === void 0 ? void 0 : _g.params),
-                    body: Object.assign(Object.assign({}, (_h = input.callback) === null || _h === void 0 ? void 0 : _h.body), (_j = callbacks.auth) === null || _j === void 0 ? void 0 : _j.body),
+                    query: Object.assign(Object.assign({}, (_g = input.callback) === null || _g === void 0 ? void 0 : _g.query), (_h = callbacks.auth) === null || _h === void 0 ? void 0 : _h.query),
+                    headers: Object.assign(Object.assign({}, (_j = input.callback) === null || _j === void 0 ? void 0 : _j.headers), (_k = callbacks.auth) === null || _k === void 0 ? void 0 : _k.headers),
+                    params: Object.assign(Object.assign({}, (_l = input.callback) === null || _l === void 0 ? void 0 : _l.params), (_m = callbacks.auth) === null || _m === void 0 ? void 0 : _m.params),
+                    body: Object.assign(Object.assign({}, (_o = input.callback) === null || _o === void 0 ? void 0 : _o.body), (_p = callbacks.auth) === null || _p === void 0 ? void 0 : _p.body),
                 };
                 input.callback.body = await this.generatePayload(payload.body, notification, additional_logs, message.callback_data.filter((data) => data.parent_key === 'body'));
                 input.callback.query = await this.generatePayload(payload.query, notification, additional_logs, message.callback_data.filter((data) => data.parent_key === 'query'));
-                input.callback.params = await this.generatePayload(payload.body, notification, additional_logs, message.callback_data.filter((data) => data.parent_key === 'params'));
-                input.callback.headers = await this.generatePayload(payload.body, notification, additional_logs, message.callback_data.filter((data) => data.parent_key === 'headers'));
+                input.callback.params = await this.generatePayload(payload.params, notification, additional_logs, message.callback_data.filter((data) => data.parent_key === 'params'));
+                input.callback.headers = await this.generatePayload(payload.headers, notification, additional_logs, message.callback_data.filter((data) => data.parent_key === 'headers'));
                 const validationPayload = (await this.inputService.parseJson({
                     data: input.callback,
                     expected: types_1.ExpectedValues.PARSEINPUT,
                 }));
                 //this.inputService.validateInput(validationPayload, message.callback_data);
-                const url = new URL(callbacks.url);
+                const callbackUrl = callbacks === null || callbacks === void 0 ? void 0 : callbacks.url;
+                if (callbackUrl == null || callbackUrl === '') {
+                    throw new Error(`Callback config has no url. Env callback config: ${JSON.stringify({ url: callbacks === null || callbacks === void 0 ? void 0 : callbacks.url, method: callbacks === null || callbacks === void 0 ? void 0 : callbacks.method, keys: callbacks ? Object.keys(callbacks) : [] })}`);
+                }
+                const url = new URL(callbackUrl);
+                const requestPayload = {
+                    query: Object.assign(Object.assign({}, (_q = input.callback) === null || _q === void 0 ? void 0 : _q.query), (_r = callbacks.auth) === null || _r === void 0 ? void 0 : _r.query),
+                    headers: Object.assign(Object.assign({}, (_s = input.callback) === null || _s === void 0 ? void 0 : _s.headers), (_t = callbacks.auth) === null || _t === void 0 ? void 0 : _t.headers),
+                    params: Object.assign(Object.assign({}, (_u = input.callback) === null || _u === void 0 ? void 0 : _u.params), (_v = callbacks.auth) === null || _v === void 0 ? void 0 : _v.params),
+                    body: Object.assign(Object.assign({}, (_w = input.callback) === null || _w === void 0 ? void 0 : _w.body), (_x = callbacks.auth) === null || _x === void 0 ? void 0 : _x.body),
+                };
                 try {
-                    await this.sendActionRequest(url.origin, url.pathname, payload, callbacks.method, '');
-                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { successful_execution: true, name: 'Send callback - success', data: {}, status: types_1.LogEventStatus.SUCCESS }));
+                    await this.sendActionRequest(url.origin, url.pathname, requestPayload, callbacks.method, '');
+                    debugLog('[runNotification] CALLBACK: success');
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { type: types_1.LogEventTypes.CALLBACKS, successful_execution: true, name: 'Send callback - success', data: {}, status: types_1.LogEventStatus.SUCCESS }));
+                    logMessageLog('callback', 'sent');
                 }
                 catch (e) {
-                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message: 'Send callback - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+                    debugLog('[runNotification] CALLBACK: failed', e);
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { type: types_1.LogEventTypes.CALLBACKS, failed_execution: true, message: 'Send callback - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+                    logMessageLog('callback', 'failed', e);
                 }
             }
-            if (sms && smses) {
+            if (sms && !smses) {
+                debugLog('[runNotification] SMS: skipped (no SMS config in env)');
+                this.lastNotificationFailureType = types_1.LogEventTypes.SMS;
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { type: types_1.LogEventTypes.SMS, message: 'SMS skipped - no SMS config in env', data: {}, status: types_1.LogEventStatus.SUCCESS }));
+            }
+            if (sms && smses && !input.sms) {
+                debugLog('[runNotification] SMS: skipped (no input.sms)');
+            }
+            if (sms && smses && input.sms) {
+                debugLog('[runNotification] SMS: processing', { recipients: (_y = input.sms.recipients) === null || _y === void 0 ? void 0 : _y.length });
+                this.lastNotificationFailureType = types_1.LogEventTypes.SMS;
                 try {
                     input.sms.body = (await (0, processor_utils_1.replacePlaceholderString)(sms, input.sms.body));
-                    const SmsClient = await (0, sms_repo_1.loadSMSClient)();
-                    const smsClient = new SmsClient(smses);
-                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { name: 'Send sms - initiated', data: { message: input.sms.body, config: (0, processor_utils_1.anonymizeObject)(smses) }, status: types_1.LogEventStatus.SUCCESS }));
+                    const smsClient = await this.getSmsClient(smses);
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { type: types_1.LogEventTypes.SMS, name: 'Send sms - initiated', data: { message: input.sms.body, config: smses }, status: types_1.LogEventStatus.SUCCESS }));
                     const res = await smsClient.sendMessage(input.sms.body, input.sms.recipients);
-                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { name: 'Send sms - success', successful_execution: true, data: res, status: types_1.LogEventStatus.SUCCESS }));
+                    if (res && res.success !== undefined && !res.success) {
+                        throw new Error(res.error);
+                    }
+                    debugLog('[runNotification] SMS: success', { res: typeof res });
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { type: types_1.LogEventTypes.SMS, name: 'Send sms - success', successful_execution: true, data: res, status: types_1.LogEventStatus.SUCCESS }));
+                    logMessageLog('sms', 'sent');
                 }
                 catch (e) {
-                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message: 'Process sms - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+                    debugLog('[runNotification] SMS: failed', e);
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { type: types_1.LogEventTypes.SMS, failed_execution: true, message: 'Process sms - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+                    logMessageLog('sms', 'failed', e);
                 }
             }
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Attempt notification - success', data: notification, status: types_1.LogEventStatus.SUCCESS }));
+            debugLog('[runNotification] DONE: all channels processed', { lastChannelType: (_z = this.lastNotificationFailureType) !== null && _z !== void 0 ? _z : 'NOTIFICATIONS' });
+            // Only add aggregate success log when we have a subtype (no NOTIFICATIONS-typed logs)
+            /*if (this.lastNotificationFailureType != null) {
+              this.logService.add({
+                ...this.baseLogs,
+                ...additional_logs,
+                type: this.lastNotificationFailureType,
+                message: 'Attempt notification - success',
+                data: notification,
+                status: LogEventStatus.SUCCESS,
+              });
+            }*/
         }
         catch (e) {
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message: 'Attempt notification - failed', data: { e: e.toString() }, status: types_1.LogEventStatus.FAIL }));
+            debugLog('[runNotification] ERROR', { error: e, lastChannelType: (_0 = this.lastNotificationFailureType) !== null && _0 !== void 0 ? _0 : 'NOTIFICATIONS' });
+            // Only add aggregate failure log when we have a subtype (no NOTIFICATIONS-typed logs)
+            if (this.lastNotificationFailureType != null) {
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { type: this.lastNotificationFailureType, failed_execution: true, message: 'Attempt notification - failed', data: { e: e.toString() }, status: types_1.LogEventStatus.FAIL }));
+            }
             //await this.logService.publish();
             throw e;
         }
@@ -3070,9 +3732,10 @@ class ProcessorService {
                 storageEnv = bootstrapData.storage_env;
             }
             else {
-                // Fallback to original API-based fetching
+                // Fallback to original API-based fetching (event may be "storage_tag:operation", lookup by storage tag only)
+                const storageTag = event.includes(':') ? event.split(':')[0] : event;
                 await this.intializeProduct(additional_logs);
-                storage = await this.productBuilderService.fetchStorage(event);
+                storage = await this.productBuilderService.fetchStorage(storageTag);
                 storageEnv = storage.envs.find((el) => el.slug === env.slug);
             }
             if (!storageEnv) {
@@ -3105,14 +3768,15 @@ class ProcessorService {
             input.mimeType = input.mimeType
                 ? await this.generateStringValues(input.mimeType, '', additional_logs, [])
                 : undefined;
-            result = await this.processStorageRequest(data, input, storageEnv, additional_logs);
+            result = await this.processStorageRequest(data, input, storageEnv, additional_logs, bootstrapData === null || bootstrapData === void 0 ? void 0 : bootstrapData.private_key);
             if (cache_tag && this.redisClient) {
                 const productCache = await this.productBuilderService.fetchCache(cache_tag);
                 if (!productCache) {
                     throw new Error('Invalid cache tag ');
                 }
                 const inputString = JSON.stringify(input);
-                await this.addToCache({
+                // Fire-and-forget cache store
+                this.addToCache({
                     input: inputString,
                     privateKey: this.productBuilderService.fetchPrivateKey(),
                     data: JSON.stringify(result),
@@ -3158,10 +3822,25 @@ class ProcessorService {
                 }
                 url = queueUrl.url;
             }
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch broker details - success', data: { event, broker }, status: types_1.LogEventStatus.SUCCESS }));
+            /*this.logService.add({
+              ...this.baseLogs,
+              ...additional_logs,
+              message: 'Fetch broker details - success',
+              data: { event, broker },
+              status: LogEventStatus.SUCCESS,
+            });*/
+            let brokerConfig = brokerEnv.config;
+            if (brokerConfig && (0, secrets_1.mightContainSecrets)(brokerConfig)) {
+                const secretsService = (0, secrets_1.getSecretsService)();
+                if (!secretsService) {
+                    throw new Error('Broker configuration contains secret references ($secret{...}) but secrets service is not initialized. Ensure secrets are configured for this environment.');
+                }
+                const resolved = await secretsService.resolve(brokerConfig, { env: env.slug });
+                brokerConfig = resolved.value;
+            }
             const createBrokerService = await loadBrokerService();
             if (createBrokerService) {
-                const brokerService = createBrokerService(brokerEnv.type, brokerEnv.config);
+                const brokerService = createBrokerService(brokerEnv.type, brokerConfig);
                 await brokerService.subscribe(url, input.callback);
                 this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { successful_execution: true, message: 'Subscribe to broker topic - success', data: { event }, status: types_1.LogEventStatus.SUCCESS }));
                 return;
@@ -3177,10 +3856,14 @@ class ProcessorService {
         }
     }
     async runBrokerPublish(data, additional_logs = {}) {
+        var _a, _b, _c, _d;
         const { env, event } = data;
         const input = data.input;
         try {
-            await this.intializeProduct(additional_logs);
+            // Skip redundant init when already initialized (e.g. same workflow run / same product)
+            if (!this.productId) {
+                await this.intializeProduct(additional_logs);
+            }
             const [brokerTag, topicTag] = event.split(':');
             const broker = await this.productBuilderService.fetchMessageBroker(brokerTag);
             if (!broker) {
@@ -3205,25 +3888,48 @@ class ProcessorService {
                 }
                 url = queueUrl.url;
             }
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetch broker details - success', data: { event, broker }, status: types_1.LogEventStatus.SUCCESS }));
-            const createBrokerService = await loadBrokerService();
-            if (createBrokerService) {
-                const brokerService = createBrokerService(brokerEnv.type, brokerEnv.config);
-                await brokerService.publish(url, input.message);
-                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Publish to broker topic - success', successful_execution: true, data: { event }, status: types_1.LogEventStatus.SUCCESS }));
-                return;
-            }
-            else {
-                throw new Error(`Running in browser, broker service not loaded.`);
-            }
+            /* this.logService.add({
+               ...this.baseLogs,
+               ...additional_logs,
+               message: 'Fetch broker details - success',
+               data: { event, broker },
+               status: LogEventStatus.SUCCESS,
+             });*/
+            let brokerConfig = brokerEnv.config;
+            if (brokerConfig && (0, secrets_1.mightContainSecrets)(brokerConfig)) {
+                const secretsService = (0, secrets_1.getSecretsService)();
+                if (!secretsService) {
+                    throw new Error('Broker configuration contains secret references ($secret{...}) but secrets service is not initialized. Ensure secrets are configured for this environment.');
+                }
+                const resolved = await secretsService.resolve(brokerConfig, { env: env.slug });
+                brokerConfig = resolved.value;
+            }
+            const brokerService = await this.getBrokerServiceForPublish(brokerEnv.type, brokerConfig);
+            await brokerService.publish(url, input.message);
+            /*this.logService.add({
+              ...this.baseLogs,
+              ...additional_logs,
+              message: 'Publish to broker topic - success',
+              successful_execution: true,
+              data: { event },
+              status: LogEventStatus.SUCCESS,
+            });*/
+            return { published: true };
             //return this.processStorageRequest(data, input, storageEnv, additional_logs);
         }
         catch (e) {
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message: 'Attempt publish to broker topic - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            const err = e;
+            const apiReason = (_b = (_a = err === null || err === void 0 ? void 0 : err.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.errors;
+            const reason = typeof apiReason === 'string'
+                ? apiReason
+                : (_d = (_c = apiReason === null || apiReason === void 0 ? void 0 : apiReason.message) !== null && _c !== void 0 ? _c : err === null || err === void 0 ? void 0 : err.message) !== null && _d !== void 0 ? _d : String(e);
+            const message = `Attempt publish to broker topic - failed: ${reason}`;
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message, data: { e, reason }, status: types_1.LogEventStatus.FAIL }));
             throw e;
         }
     }
-    async processStorageRequest(data, input, storageEnv, additional_logs) {
+    async processStorageRequest(data, input, storageEnv, additional_logs, decryptionKey) {
+        var _a, _b, _c, _d, _e, _f, _g;
         try {
             /*const result = await this.processorApiService.processProduct(
               this.productId,
@@ -3236,7 +3942,23 @@ class ProcessorService {
               },
               this.getUserAccess(),
             );*/
-            const cloudConfig = storageEnv.config;
+            // Bootstrap returns raw storage_env; config may be encrypted - decrypt before use
+            // Prefer decryptionKey from bootstrap (workflow path) so we use the exact key the backend returned
+            let cloudConfig = storageEnv.config;
+            if (typeof cloudConfig === 'string') {
+                const privateKey = decryptionKey !== null && decryptionKey !== void 0 ? decryptionKey : this.productBuilderService.fetchPrivateKey();
+                if (!privateKey)
+                    throw new Error('Storage config is encrypted but private_key is not available');
+                cloudConfig = JSON.parse((0, processor_utils_1.decrypt)(cloudConfig, privateKey));
+            }
+            // Resolve $Secret{...} references in config (e.g. GCP private_key) so upload receives real credentials
+            if (cloudConfig && typeof cloudConfig === 'object' && (0, secrets_1.mightContainSecrets)(cloudConfig)) {
+                const secretsService = (0, secrets_1.getSecretsService)();
+                if (secretsService) {
+                    const resolved = await secretsService.resolve(cloudConfig, { env: storageEnv.slug });
+                    cloudConfig = resolved.value;
+                }
+            }
             const config = {
                 provider: storageEnv.type,
             };
@@ -3246,8 +3968,8 @@ class ProcessorService {
             if (storageEnv.type === types_1.StorageProviders.GCP) {
                 Object.assign(config, { gcpConfig: cloudConfig });
             }
-            if (storageEnv.type === types_1.StorageProviders.AWS) {
-                Object.assign(config, { awsConfig: cloudConfig });
+            if (storageEnv.type === types_1.StorageProviders.AZURE) {
+                Object.assign(config, { azureConfig: cloudConfig });
             }
             const result = { url: await (0, storage_util_1.uploadBlobToCloud)({ data: input.buffer, destinationPath: input.fileName, config }) };
             try {
@@ -3269,7 +3991,13 @@ class ProcessorService {
             return result;
         }
         catch (e) {
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message: 'Run storage request - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
+            const err = e;
+            const apiReason = (_b = (_a = err === null || err === void 0 ? void 0 : err.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.errors;
+            const reason = typeof apiReason === 'string'
+                ? apiReason
+                : (_g = (_f = (_c = apiReason === null || apiReason === void 0 ? void 0 : apiReason.message) !== null && _c !== void 0 ? _c : (_e = (_d = err === null || err === void 0 ? void 0 : err.response) === null || _d === void 0 ? void 0 : _d.data) === null || _e === void 0 ? void 0 : _e.message) !== null && _f !== void 0 ? _f : err === null || err === void 0 ? void 0 : err.message) !== null && _g !== void 0 ? _g : String(e);
+            const message = `Run storage request - failed: ${reason}`;
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { failed_execution: true, message, data: { e, reason }, status: types_1.LogEventStatus.FAIL }));
             const value = await this.addToFailureOutput(e, data, { storageEnv }, additional_logs);
             if (value) {
                 return value;
@@ -3405,7 +4133,7 @@ class ProcessorService {
     }
     async processAction(action) {
         //TODO: schema validation
-        const { env, input, retries, action: event, app, product: product_tag, session, cache } = action;
+        const { env, input, retries, action: event, app, product: product_tag, session, cache, preloadedBootstrap } = action;
         const additional_logs = {
             parent_tag: (0, string_utils_1.extractOriginAndTag)(app),
             child_tag: event,
@@ -3431,13 +4159,47 @@ class ProcessorService {
                 process_id,
                 data: input,
             };
-            // Single ultra-lightweight bootstrap call - returns action data directly
-            const bootstrapData = await this.productBuilderService.bootstrapAction({
-                product_tag,
-                env_slug: env,
-                access_tag: app,
-                action_tag: event,
-            });
+            this.process_id = process_id;
+            // Initialize log service early to ensure error handling works
+            if (!this.logService) {
+                this.logService = new logs_service_1.default({
+                    product_id: this.productId,
+                    workspace_id: this.workspace_id,
+                    public_key: this.public_key,
+                    user_id: this.user_id,
+                    token: this.token,
+                    env_type: this.environment,
+                });
+            }
+            // Early cache check - before expensive bootstrap/API calls
+            if (cache && this.redisClient) {
+                const productCache = await this.productBuilderService.fetchCache(cache);
+                if (productCache) {
+                    const inputString = JSON.stringify(input);
+                    const cachedResult = await this.fetchFromCache({
+                        cache_tag: cache,
+                        input: inputString,
+                        privateKey: this.productBuilderService.fetchPrivateKey(),
+                        expiry: productCache.expiry,
+                    }, additional_logs);
+                    if (cachedResult) {
+                        const result = JSON.parse(cachedResult);
+                        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Action response from cache (early check)', data: { result: (0, processor_utils_1.anonymizeObject)(result) }, status: types_1.LogEventStatus.SUCCESS, cache_tag: cache, action: event }));
+                        this.end = Date.now();
+                        await this.logService.publish();
+                        return result;
+                    }
+                }
+            }
+            // Use preloaded bootstrap when provided (e.g. workflow batch prefetch), otherwise fetch
+            const bootstrapData = preloadedBootstrap
+                ? preloadedBootstrap
+                : await this.productBuilderService.bootstrapAction({
+                    product_tag,
+                    env_slug: env,
+                    access_tag: app,
+                    action_tag: event,
+                });
             // Initialize from bootstrap data
             if (bootstrapData.product_id) {
                 this.productId = bootstrapData.product_id;
@@ -3508,25 +4270,19 @@ class ProcessorService {
             // Process session if provided - verify and resolve $Session{} references
             if (session && bootstrapData.private_key) {
                 const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../../sessions')));
-                const sessionResult = await processSessionForExecution(session, bootstrapData.private_key, resolvedInput, env);
+                const sessionResult = await processSessionForExecution(session, bootstrapData.private_key, resolvedInput, env, {
+                    fetchSessionSelector: async (sessionTag) => {
+                        const sessionConfig = await this.productBuilderService.fetchSession(sessionTag);
+                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
+                    },
+                });
                 if (sessionResult.error) {
                     throw new Error(`Session validation failed: ${sessionResult.error}`);
                 }
                 resolvedInput = sessionResult.input;
                 sessionLogFields = sessionResult.logFields;
             }
-            // Initialize log service if needed
-            if (!this.logService) {
-                this.logService = new logs_service_1.default({
-                    product_id: this.productId,
-                    workspace_id: this.workspace_id,
-                    public_key: this.public_key,
-                    user_id: this.user_id,
-                    token: this.token,
-                    env_type: this.environment,
-                });
-            }
-            this.process_id = process_id;
+            // Update log service with product_id from bootstrap
             this.baseLogs.product_id = this.productId;
             // Add session fields to base logs
             this.baseLogs = Object.assign(Object.assign({}, this.baseLogs), sessionLogFields);
@@ -3535,6 +4291,7 @@ class ProcessorService {
                 type: types_1.FeatureEventTypes.ACTION,
                 event,
                 cache: cache,
+                skipCacheFetch: true, // Early cache check already done above, skip duplicate fetch
                 app,
                 input: resolvedInput,
                 env: this.processEnv,
@@ -3555,20 +4312,23 @@ class ProcessorService {
             return result;
         }
         catch (e) {
-            console.log('ERRRRROORRRRR!!!!!!', e);
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Execute action - failed', data: { e: e.toString() }, status: types_1.LogEventStatus.FAIL }));
-            this.end = Date.now();
-            await this.writeResult(types_1.LogEventStatus.FAIL);
-            await this.logService.publish();
-            return { process_id: this.process_id };
+            if (this.logService) {
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Execute action - failed', data: { e: e.toString() }, status: types_1.LogEventStatus.FAIL }));
+                this.end = Date.now();
+                await this.writeResult(types_1.LogEventStatus.FAIL);
+                await this.logService.publish();
+            }
+            throw e;
         }
     }
     async processNotification(action) {
         //TODO: schema validation
-        var _a;
-        const { env, input, retries, event, product: product_tag, session, cache } = action;
+        var _a, _b, _c, _d, _e;
+        const { env, input, retries, event, product: product_tag, session, cache, preloadedBootstrap } = action;
+        debugLog('[processNotification] ENTRY', { product: product_tag, env, event, inputKeys: input ? Object.keys(input) : [], hasSession: !!session, hasCache: !!cache });
         const [parent_tag, child_tag] = event.split(':');
         if (!parent_tag || !child_tag) {
+            debugLog('[processNotification] ERROR: invalid event format', { event });
             throw new Error(`database action events should be in the format notification_tag:message_tag`);
         }
         this.component = types_1.LogEventTypes.NOTIFICATIONS;
@@ -3582,34 +4342,34 @@ class ProcessorService {
         let sessionLogFields = {};
         let resolvedInput = input;
         try {
+            this.productTag = product_tag;
+            if (!preloadedBootstrap) {
+                debugLog('[processNotification] Initializing product by tag', { product_tag });
+                await this.productBuilderService.initializeProductByTag(product_tag);
+            }
+            debugLog('[processNotification] Validating input');
             await this.validateActionDataMappingInput(input, types_1.FeatureEventTypes.NOTIFICATION);
             this.input = action;
             this.start = Date.now();
-            this.productTag = product_tag;
             const process_id = (0, processor_utils_1.generateObjectId)();
+            debugLog('[processNotification] process_id', process_id);
             this.baseLogs = Object.assign({ product_tag: this.productTag, workspace_id: this.workspace_id, env,
                 process_id, data: input }, additional_logs);
-            // Single bootstrap call to fetch all notification data
-            const bootstrapData = await this.productBuilderService.bootstrapNotification({
-                product_tag,
-                env_slug: env,
-                notification_tag: parent_tag,
-                message_tag: child_tag,
-            });
+            this.lastNotificationFailureType = undefined;
+            // Use preloaded bootstrap when provided (e.g. workflow batch prefetch), otherwise fetch
+            const bootstrapData = preloadedBootstrap
+                ? preloadedBootstrap
+                : await this.productBuilderService.bootstrapNotification({
+                    product_tag,
+                    env_slug: env,
+                    notification_tag: parent_tag,
+                    message_tag: child_tag,
+                });
+            debugLog('[processNotification] Bootstrap result', { product_id: bootstrapData === null || bootstrapData === void 0 ? void 0 : bootstrapData.product_id, hasNotification: !!(bootstrapData === null || bootstrapData === void 0 ? void 0 : bootstrapData.notification), hasMessage: !!(bootstrapData === null || bootstrapData === void 0 ? void 0 : bootstrapData.message), envActive: (_a = bootstrapData === null || bootstrapData === void 0 ? void 0 : bootstrapData.env) === null || _a === void 0 ? void 0 : _a.active });
             // Initialize from bootstrap data
             this.productId = bootstrapData.product_id;
             this.processEnv = bootstrapData.env;
-            // Process session if provided - verify and resolve $Session{} references
-            if (session && bootstrapData.private_key) {
-                const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../../sessions')));
-                const sessionResult = await processSessionForExecution(session, bootstrapData.private_key, input, env);
-                if (sessionResult.error) {
-                    throw new Error(`Session validation failed: ${sessionResult.error}`);
-                }
-                resolvedInput = sessionResult.input;
-                sessionLogFields = sessionResult.logFields;
-            }
-            // Initialize log service if needed
+            // Initialize log service as soon as we have productId so the catch block can record failures
             if (!this.logService) {
                 this.logService = new logs_service_1.default({
                     product_id: this.productId,
@@ -3621,6 +4381,21 @@ class ProcessorService {
                 });
             }
             this.process_id = process_id;
+            // Process session if provided - verify and resolve $Session{} references
+            if (session && bootstrapData.private_key) {
+                const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../../sessions')));
+                const sessionResult = await processSessionForExecution(session, bootstrapData.private_key, input, env, {
+                    fetchSessionSelector: async (sessionTag) => {
+                        const sessionConfig = await this.productBuilderService.fetchSession(sessionTag);
+                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
+                    },
+                });
+                if (sessionResult.error) {
+                    throw new Error(`Session validation failed: ${sessionResult.error}`);
+                }
+                resolvedInput = sessionResult.input;
+                sessionLogFields = sessionResult.logFields;
+            }
             this.baseLogs.product_id = this.productId;
             // Add session fields to base logs
             this.baseLogs = Object.assign(Object.assign({}, this.baseLogs), sessionLogFields);
@@ -3638,25 +4413,152 @@ class ProcessorService {
                 allow_fail: false,
             };
             // Find the env config for the notification
-            const envConfig = (_a = bootstrapData.notification.envs) === null || _a === void 0 ? void 0 : _a.find((data) => data.slug === env);
+            const envConfig = (_b = bootstrapData.notification.envs) === null || _b === void 0 ? void 0 : _b.find((data) => data.slug === env);
+            debugLog('[processNotification] Calling runNotification', { event, resolvedInputKeys: resolvedInput ? Object.keys(resolvedInput) : [] });
             const result = await this.runNotification(payload, additional_logs, {
                 notification: bootstrapData.notification,
                 message: bootstrapData.message,
                 env_config: envConfig,
+                product_tag,
+                env,
+                process_id,
+                session,
+                cache,
             });
             this.end = Date.now();
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Send notification - success', data: { input: (0, processor_utils_1.anonymizeObject)(input), result: (0, processor_utils_1.anonymizeObject)(result) }, status: types_1.LogEventStatus.SUCCESS }));
+            debugLog('[processNotification] SUCCESS', { process_id, lastChannelType: (_c = this.lastNotificationFailureType) !== null && _c !== void 0 ? _c : 'NOTIFICATIONS', durationMs: this.end - this.start });
+            // Only add success log when we have a subtype (no NOTIFICATIONS-typed logs)
+            /* if (this.lastNotificationFailureType != null) {
+              this.logService.add({
+                ...this.baseLogs,
+                ...additional_logs,
+                type: this.lastNotificationFailureType,
+                message: 'Send notification - success',
+                data: { input, result },
+                status: LogEventStatus.SUCCESS,
+              });
+            }*/
             await this.writeResult(types_1.LogEventStatus.SUCCESS);
-            await this.logService.publish();
-            return { process_id };
+            // Fire-and-forget so step latency isn't dominated by log upload
+            this.logService.publish().catch(() => { });
+            // Per-channel message logs are emitted inside runNotification (type: email | push | sms | callback).
+            return { process_id, output: { sent: true } };
         }
         catch (e) {
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Send notification - failed', data: { e }, status: types_1.LogEventStatus.FAIL }));
-            this.end = Date.now();
-            await this.logService.publish();
-            return { process_id: this.process_id };
+            if (this.logService) {
+                debugLog('[processNotification] FAILED', { error: e, lastChannelType: (_d = this.lastNotificationFailureType) !== null && _d !== void 0 ? _d : 'NOTIFICATIONS' });
+                console.error(e);
+                // Only add failure log when we have a subtype (no NOTIFICATIONS-typed logs)
+                if (this.lastNotificationFailureType != null) {
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { type: this.lastNotificationFailureType, message: 'Send notification - failed', data: { e: e.toString() }, status: types_1.LogEventStatus.FAIL }));
+                }
+                this.end = Date.now();
+                this.logService.publish().catch(() => { });
+            }
+            // Fire-and-forget: log failed notification for reprocessing (only when we have productId from bootstrap). Use actual channel type when known.
+            if (this.productId && this.workspace_id) {
+                const channelType = this.lastNotificationFailureType === types_1.LogEventTypes.PUSH ? 'push' : this.lastNotificationFailureType === types_1.LogEventTypes.EMAIL ? 'email' : this.lastNotificationFailureType === types_1.LogEventTypes.SMS ? 'sms' : this.lastNotificationFailureType === types_1.LogEventTypes.CALLBACKS ? 'callback' : 'notification';
+                this.fireAndForgetLogNotificationMessage({
+                    workspace_id: this.workspace_id,
+                    product_id: this.productId,
+                    product_tag,
+                    env,
+                    notification_tag: event,
+                    input: ((_e = resolvedInput !== null && resolvedInput !== void 0 ? resolvedInput : input) !== null && _e !== void 0 ? _e : {}),
+                    type: channelType,
+                    status: 'failed',
+                    process_id: this.process_id,
+                    retries: retries !== null && retries !== void 0 ? retries : 0,
+                    session,
+                    cache,
+                    error: e instanceof Error ? e.message : String(e),
+                });
+            }
+            // Rethrow so workflow/callers see the step as failed (e.g. bootstrap "Notification not found" or runNotification failure)
+            throw e;
         }
     }
+    /**
+     * Fire-and-forget log of notification message send to integrations backend (for reprocessing).
+     * Input is encrypted with the product private key before sending. Does not block or affect latency; errors are swallowed.
+     */
+    fireAndForgetLogNotificationMessage(payload) {
+        debugLog('[fireAndForgetLogNotificationMessage] ENTRY', {
+            workspace_id: payload.workspace_id,
+            product_tag: payload.product_tag,
+            env: payload.env,
+            notification_tag: payload.notification_tag,
+            type: payload.type,
+            status: payload.status,
+            process_id: payload.process_id,
+            inputKeys: payload.input ? Object.keys(payload.input) : [],
+        });
+        let inputToSend = payload.input;
+        try {
+            const privateKey = this.productBuilderService.fetchPrivateKey();
+            if (privateKey) {
+                inputToSend = (0, processor_utils_1.encrypt)(JSON.stringify(payload.input), privateKey);
+                debugLog('[fireAndForgetLogNotificationMessage] input encrypted', { inputLength: String(inputToSend).length });
+            }
+            else {
+                debugLog('[fireAndForgetLogNotificationMessage] no private key, sending input as plain object');
+            }
+        }
+        catch (e) {
+            debugLog('[fireAndForgetLogNotificationMessage] encrypt failed, sending input as-is', e);
+            // No private key or encrypt failed: send input as-is (e.g. legacy or edge case)
+        }
+        void this.processorApiService
+            .logNotificationMessage(Object.assign(Object.assign({}, payload), { input: inputToSend }), Object.assign(Object.assign({}, this.getUserAccess()), { access_key: this.accessKey }))
+            .then(() => debugLog('[fireAndForgetLogNotificationMessage] POST success', { process_id: payload.process_id }))
+            .catch((err) => console.error('[fireAndForgetLogNotificationMessage] POST failed', { process_id: payload.process_id, error: err }));
+    }
+    /**
+     * Fetch notification message logs (send history) with time filters. Secured via user auth.
+     * Each item's input is decrypted with the product private key when stored as an encrypted string.
+     */
+    async getNotificationMessageLogs(options) {
+        const result = await this.processorApiService.queryNotificationMessageLogs(Object.assign({ workspace_id: this.workspace_id }, options), this.getUserAccess());
+        // Initialize product so productBuilderService has private_key for decryption
+        const productRef = options.product_tag || options.product_id;
+        if (productRef) {
+            try {
+                if (options.product_id) {
+                    await this.productBuilderService.initializeProduct(options.product_id);
+                }
+                else {
+                    await this.productBuilderService.initializeProductByTag(options.product_tag);
+                }
+            }
+            catch (_a) {
+                // Return result without decryption if product init fails
+                return result;
+            }
+        }
+        let privateKey;
+        try {
+            privateKey = this.productBuilderService.fetchPrivateKey();
+        }
+        catch (_b) {
+            return result;
+        }
+        if (!privateKey) {
+            return result;
+        }
+        const items = result.items.map((item) => {
+            if (typeof item.input !== 'string') {
+                return item;
+            }
+            try {
+                const decrypted = (0, processor_utils_1.decrypt)(item.input, privateKey);
+                return Object.assign(Object.assign({}, item), { input: JSON.parse(decrypted) });
+            }
+            catch (_a) {
+                return item;
+            }
+        });
+        return Object.assign(Object.assign({}, result), { items });
+    }
     async fetchRemoteCaches(payload) {
         try {
             const data = await this.processorApiService.fetchRemoteCaches(payload, this.getUserAccess());
@@ -3677,57 +4579,62 @@ class ProcessorService {
             public_key: this.public_key,
         };
     }
-    async addToCache(payload, additional_logs) {
-        if (!this.redisClient) {
-            throw 'redis client not setup';
-        }
+    /**
+     * Add data to cache - fire-and-forget pattern.
+     * Does not block the main operation.
+     */
+    addToCache(payload, additional_logs) {
         const { input, privateKey, data, cache_tag, timestamp, expiry, product_tag, component_tag, component_type } = payload;
         // sha-512 instead of md5, private key is fetch product.privatekey
         const key = `${cache_tag}-${CryptoJS.SHA512(input)}`;
         const encryptedData = (0, processor_utils_1.encrypt)(data, privateKey);
-        let expiresAt = null;
+        let expiresAt = undefined;
         if (expiry) {
-            expiresAt = timestamp + expiry;
-        }
-        await this.processorApiService.addToRemoteCache(Object.assign(Object.assign({}, (expiresAt && { expiry: new Date(expiresAt) })), { key, value: encryptedData, cache_tag,
-            product_tag,
-            component_tag,
-            component_type }), this.getUserAccess());
-        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Renewing expired Cache Value', data: { key }, successful_execution: true, status: types_1.LogEventStatus.SUCCESS, cache_tag }));
-        await this.redisClient.hSet(key, 'data', encryptedData);
-        await this.redisClient.hSet(key, 'lastUpdated', timestamp);
+            expiresAt = new Date(timestamp + expiry);
+        }
+        // Use CacheService to store the value (fire-and-forget)
+        this.cacheService.set({
+            product: product_tag,
+            cache: cache_tag,
+            key,
+            value: encryptedData,
+            componentTag: component_tag,
+            componentType: component_type,
+            expiry: expiresAt,
+        }).then(() => {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Cache value stored', data: { key }, successful_execution: true, status: types_1.LogEventStatus.SUCCESS, cache_tag, cache_key: key }));
+        }).catch((error) => {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Cache store failed (non-blocking)', data: { key, error: String(error) }, status: types_1.LogEventStatus.FAIL, cache_tag, cache_key: key }));
+        });
     }
     async fetchFromCache(payload, additional_logs) {
-        var _a;
         const { input, privateKey, cache_tag, expiry } = payload;
         const key = `${cache_tag}-${CryptoJS.SHA512(input)}`;
-        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetching from Cache', data: { key }, status: types_1.LogEventStatus.PROCESSING, cache_tag }));
-        if (!this.redisClient) {
-            return null;
-        }
-        let record = await this.redisClient.hGetAll(key);
-        if (!record || !record.data || !record.lastUpdated) {
-            const checkRemote = await this.processorApiService.fetchRemoteCacheByKey(key, this.getUserAccess());
-            if (!checkRemote) {
-                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Remote Cache Not Found', data: { key }, successful_execution: true, status: types_1.LogEventStatus.FAIL, cache_tag }));
+        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Fetching from Cache', data: { key }, status: types_1.LogEventStatus.PROCESSING, cache_tag, cache_key: key }));
+        try {
+            // Use CacheService to fetch the value
+            const cacheValue = await this.cacheService.get({ key });
+            if (!cacheValue) {
+                this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Remote Cache Not Found', data: { key }, successful_execution: true, status: types_1.LogEventStatus.FAIL, cache_tag, cache_key: key, cache_status: false }));
                 return null;
             }
-            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Remote Cache Found', data: { key }, successful_execution: true, status: types_1.LogEventStatus.SUCCESS, cache_tag }));
-            record = { data: checkRemote.value, expiresAt: (_a = checkRemote.expiry) === null || _a === void 0 ? void 0 : _a.getTime().toString() };
-        }
-        if (record.lastUpdated) {
-            const lastUpdated = Number(record.lastUpdated);
-            if (expiry) {
-                const expiryTime = lastUpdated + expiry;
+            // Check expiry if provided
+            if (expiry && cacheValue.expiry) {
+                const expiryTime = new Date(cacheValue.expiry).getTime();
                 if (Date.now() > expiryTime) {
-                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Deleting expired Cache Value', data: { key }, successful_execution: true, status: types_1.LogEventStatus.SUCCESS, cache_tag }));
-                    await this.redisClient.del(key);
+                    this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Deleting expired Cache Value', data: { key }, successful_execution: true, status: types_1.LogEventStatus.SUCCESS, cache_tag, cache_key: key }));
+                    await this.cacheService.clear({ key });
                     return null;
                 }
             }
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Cache Found', data: { key }, successful_execution: true, status: types_1.LogEventStatus.SUCCESS, cache_tag, cache_key: key, cache_status: true }));
+            // Decrypt the value (CacheService returns encrypted value)
+            return (0, processor_utils_1.decrypt)(cacheValue.value, privateKey);
+        }
+        catch (error) {
+            this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Cache fetch error', data: { key, error: String(error) }, successful_execution: false, status: types_1.LogEventStatus.FAIL, cache_tag, cache_key: key, cache_status: false }));
+            return null;
         }
-        this.logService.add(Object.assign(Object.assign(Object.assign({}, this.baseLogs), additional_logs), { message: 'Cache Found', data: { key }, successful_execution: true, status: types_1.LogEventStatus.SUCCESS, cache_tag }));
-        return (0, processor_utils_1.decrypt)(record.data, privateKey);
     }
     /**
      * Writes the healthcheck result to Redis cache for fast status retrieval.
@@ -3736,9 +4643,9 @@ class ProcessorService {
         if (!this.redisClient)
             return;
         const key = `healthcheck:${data.product}:${data.healthcheck}:${data.env}`;
-        console.log('LOG TO CACHE', key, JSON.stringify(result));
+        debugLog('LOG TO CACHE', key, JSON.stringify(result));
         await this.redisClient.set(key, JSON.stringify(result));
-        console.log();
+        debugLog();
     }
     /**
      * Fetches the latest healthcheck status for a product/env from Redis cache.