backend-manager 5.0.83 → 5.0.85

package/src/manager/functions/core/actions/api/user/get-subscription-info.js

@@ -29,7 +29,7 @@ Module.prototype.main = function () {
             timestampUNIX: user?.subscription?.expires?.timestampUNIX || oldDateUNIX,
           },
           trial: {
-            activated: user?.subscription?.trial?.activated ?? false,
+            claimed: user?.subscription?.trial?.claimed ?? false,
             expires: {
               timestamp: user?.subscription?.trial?.expires?.timestamp || oldDate,
               timestampUNIX: user?.subscription?.trial?.expires?.timestampUNIX || oldDateUNIX,

package/src/manager/helpers/analytics.js

@@ -113,8 +113,8 @@ function Analytics(Manager, options) {
     subscription_id: {
       value: authUser?.subscription?.product?.id || 'basic',
     },
-    subscription_trial_activated: {
-      value: authUser?.subscription?.trial?.activated || false,
+    subscription_trial_claimed: {
+      value: authUser?.subscription?.trial?.claimed || false,
     },
     activity_created: {
       value: moment(authUser?.activity?.created?.timestampUNIX

package/src/manager/helpers/api-manager.js

@@ -54,7 +54,7 @@ ApiManager.prototype.init = function (options) {
     options.whitelistedAPIKeys = options.whitelistedAPIKeys || [];
 
     // Read limits from config products
-    const products = self.Manager.config.products || [];
+    const products = self.Manager.config.payment?.products || [];
     options.plans = {};
 
     for (const product of products) {

package/src/manager/helpers/middleware.js

@@ -220,7 +220,7 @@ function clean(obj) {
 function stripUrl(url) {
   const newUrl = new URL(url);
 
-  return `${newUrl.hostname}${newUrl.pathname}`.replace(/\/$/, '');
+  return `${newUrl.host}${newUrl.pathname}`.replace(/\/$/, '');
 }
 
 // Helper to safely stringify objects by truncating long strings (like base64)

package/src/manager/helpers/usage.js

@@ -1,7 +1,7 @@
 /**
  * Usage
  * Meant to check and update usage for a user
- * Reads product limits from Manager.config.products
+ * Reads product limits from Manager.config.payment.products
  * Stores usage in the user's firestore document OR in local/temp storage if no user
  */
 
@@ -142,7 +142,21 @@ Usage.prototype.validate = function (name, options) {
       return resolve(true);
     }
 
-    // If they are under the limit, resolve
+    // Check proportional daily allowance (for products with rateLimit: 'daily')
+    const dailyAllowance = self.getDailyAllowance(name);
+    if (dailyAllowance !== null) {
+      if (options.log) {
+        assistant.log(`Usage.validate(): Daily allowance check: ${period}/${dailyAllowance} (monthly: ${allowed}) for ${name} (${self.key})`);
+      }
+
+      if (period >= dailyAllowance) {
+        return reject(
+          assistant.errorify(`You have reached your daily usage limit for ${name} (${period}/${dailyAllowance}). Your monthly limit is ${allowed}.`, {code: 429})
+        );
+      }
+    }
+
+    // If they are under the monthly limit, resolve
     if (period < allowed) {
       self.log(`Usage.validate(): Valid for ${name}`);
 
@@ -252,7 +266,7 @@ Usage.prototype.getProduct = function (id) {
   const self = this;
   const Manager = self.Manager;
 
-  const products = Manager.config.products || [];
+  const products = Manager.config.payment?.products || [];
 
   // Look up by provided ID, or fall back to user's subscription product
   id = id || self.user.subscription.product.id;
@@ -275,6 +289,40 @@ Usage.prototype.getLimit = function (name) {
   return limits;
 };
 
+/**
+ * Get the proportional daily allowance for a metric
+ * Based on how far into the month we are: ceil(monthlyLimit * dayOfMonth / daysInMonth)
+ *
+ * Returns null if the product uses monthly rate limiting (no daily cap)
+ * Products can set rateLimit: 'daily' | 'monthly' (default: 'monthly')
+ */
+Usage.prototype.getDailyAllowance = function (name) {
+  const self = this;
+
+  // Get the product config
+  const product = self.getProduct();
+  const rateLimit = product.rateLimit || 'monthly';
+
+  // If monthly rate limiting, no daily cap
+  if (rateLimit !== 'daily') {
+    return null;
+  }
+
+  // Get the monthly limit
+  const monthlyLimit = self.getLimit(name);
+  if (!monthlyLimit) {
+    return null;
+  }
+
+  // Calculate proportional allowance based on day of month
+  const now = new Date();
+  const dayOfMonth = now.getDate();
+  const daysInMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0).getDate();
+
+  // ceil ensures at least 1 usage per day even with very low limits
+  return Math.ceil(monthlyLimit * (dayOfMonth / daysInMonth));
+};
+
 Usage.prototype.update = function () {
   const self = this;
 

package/src/manager/index.js

@@ -133,8 +133,6 @@ Manager.prototype.init = function (exporter, options) {
     {},
     requireJSON5(BEM_CONFIG_TEMPLATE_PATH, true),
     requireJSON5(self.project.backendManagerConfigPath, true),
-    // Load RUNTIME_CONFIG from .env (deprecated, will be removed in future versions)
-    process.env.RUNTIME_CONFIG ? JSON5.parse(process.env.RUNTIME_CONFIG) : {},
   );
 
   // Resolve legacy paths
@@ -395,7 +393,7 @@ Manager.prototype._preProcess = function (mod) {
   });
 };
 
-Manager.prototype._processMiddleware = function (req, res, routePath, options) {
+Manager.prototype._processMiddleware = function (req, res, routePath) {
   const self = this;
 
   // Set paths for BEM internal routes/schemas
@@ -403,11 +401,11 @@ Manager.prototype._processMiddleware = function (req, res, routePath, options) {
   const bemSchemasDir = path.resolve(__dirname, './schemas');
 
   // Route directly through middleware (no hooks for new system)
-  return self.Middleware(req, res).run(routePath, Object.assign({
+  return self.Middleware(req, res).run(routePath, {
     routesDir: bemRoutesDir,
     schemasDir: bemSchemasDir,
     schema: routePath,
-  }, options || {}));
+  });
 };
 
 // Manager.prototype.Assistant = function(ref, options) {
@@ -717,17 +715,6 @@ Manager.prototype.setupFunctions = function (exporter, options) {
     self.assistant.log('Setting up Firebase functions...');
   }
 
-  // Route-specific middleware overrides
-  // Routes listed here get custom middleware options (e.g., skip auth for webhooks)
-  const routeMiddlewareOverrides = {
-    'payments/webhook': {
-      authenticate: false,
-      setupUsage: false,
-      setupAnalytics: false,
-      includeNonSchemaSettings: true,
-    },
-  };
-
   // Setup functions
   exporter.bm_api =
   self.libraries.functions
@@ -740,8 +727,7 @@ Manager.prototype.setupFunctions = function (exporter, options) {
       return self._process((new (require(`${core}/actions/api.js`))()).init(self, { req, res }));
     } else {
       // New RESTful middleware system -> direct to middleware (no hooks)
-      const overrides = routeMiddlewareOverrides[route.routePath];
-      return self._processMiddleware(req, res, route.routePath, overrides);
+      return self._processMiddleware(req, res, route.routePath);
     }
   });
 
@@ -944,7 +930,7 @@ Manager.prototype.setupFunctions = function (exporter, options) {
   exporter.bm_cronDaily =
   self.libraries.functions
   .runWith({ memory: '256MB', timeoutSeconds: 60 * 5})
-  .pubsub.schedule('every 24 hours')
+  .pubsub.schedule('0 0 * * *')
   .onRun((context) => self.EventMiddleware({ context }).run(`${cron}/daily.js`));
 };
 

package/src/manager/libraries/stripe.js

@@ -76,7 +76,6 @@ const Stripe = {
       expires: expires,
       trial: trial,
       cancellation: cancellation,
-      limits: {},
       payment: {
         processor: 'stripe',
         resourceId: rawSubscription.id || null,
@@ -135,9 +134,10 @@ function resolveCancellation(raw) {
 
   // Pending cancellation: active but set to cancel at period end
   if (raw.cancel_at_period_end) {
+    const periodEnd = raw.current_period_end || raw.items?.data?.[0]?.current_period_end || 0;
     const cancelAt = raw.cancel_at
       ? powertools.timestamp(new Date(raw.cancel_at * 1000), { output: 'string' })
-      : powertools.timestamp(new Date((raw.current_period_end || 0) * 1000), { output: 'string' });
+      : powertools.timestamp(new Date(periodEnd * 1000), { output: 'string' });
 
     return {
       pending: true,
@@ -193,7 +193,7 @@ function resolveTrial(raw) {
   }
 
   return {
-    activated: activated,
+    claimed: activated,
     expires: trialExpires,
   };
 }
@@ -236,12 +236,12 @@ function resolveProduct(raw, config) {
     || raw.items?.data?.[0]?.price?.id
     || null;
 
-  if (!priceId || !config.products) {
+  if (!priceId || !config.payment?.products) {
     return { id: 'basic', name: 'Basic' };
   }
 
   // Search through products for a matching price ID
-  for (const product of config.products) {
+  for (const product of config.payment.products) {
     if (!product.prices) {
       continue;
     }
@@ -261,9 +261,13 @@ function resolveProduct(raw, config) {
  * Resolve subscription expiration from Stripe data
  */
 function resolveExpires(raw, oldDate, oldDateUNIX) {
-  // For active/trialing subscriptions, use current_period_end
-  const periodEnd = raw.current_period_end
-    ? powertools.timestamp(new Date(raw.current_period_end * 1000), { output: 'string' })
+  // Stripe API 2025+ moves period dates to items.data[0]
+  const periodEndRaw = raw.current_period_end
+    || raw.items?.data?.[0]?.current_period_end
+    || 0;
+
+  const periodEnd = periodEndRaw
+    ? powertools.timestamp(new Date(periodEndRaw * 1000), { output: 'string' })
     : oldDate;
 
   return {

package/src/manager/libraries/test.js

@@ -0,0 +1,27 @@
+const Stripe = require('./stripe.js');
+
+/**
+ * Test processor library
+ * Delegates to Stripe's toUnified() since test processor generates Stripe-shaped data
+ * Stamps processor as 'test' to distinguish from real Stripe subscriptions
+ */
+const Test = {
+  /**
+   * No-op init — test processor doesn't need an external SDK
+   */
+  init() {
+    return null;
+  },
+
+  /**
+   * Transform raw subscription into unified shape
+   * Delegates to Stripe's toUnified (same data shape), stamps processor as 'test'
+   */
+  toUnified(rawSubscription, options) {
+    const unified = Stripe.toUnified(rawSubscription, options);
+    unified.payment.processor = 'test';
+    return unified;
+  },
+};
+
+module.exports = Test;

package/src/manager/routes/app/get.js

@@ -26,14 +26,17 @@ function buildPublicConfig(config) {
     },
     reviews: config.reviews || {},
     firebaseConfig: config.firebaseConfig || {},
-    products: (config.products || []).map(p => ({
-      id: p.id,
-      name: p.name,
-      type: p.type,
-      limits: p.limits || {},
-      trial: p.trial || {},
-      prices: p.prices || {},
-    })),
+    payment: {
+      processors: config.payment?.processors || {},
+      products: (config.payment?.products || []).map(p => ({
+        id: p.id,
+        name: p.name,
+        type: p.type,
+        limits: p.limits || {},
+        trial: p.trial || {},
+        prices: p.prices || {},
+      })),
+    },
   };
 }
 

package/src/manager/routes/payments/intent/post.js

@@ -18,51 +18,66 @@ module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
   const processor = settings.processor;
   const productId = settings.productId;
   const frequency = settings.frequency;
-  const trial = settings.trial;
+  let trial = settings.trial;
+
+  assistant.log(`Intent request: uid=${uid}, processor=${processor}, product=${productId}, frequency=${frequency}, trial=${trial}`);
 
   // Check if user already has an active non-basic subscription
   if (user.subscription?.status === 'active' && user.subscription?.product?.id !== 'basic') {
+    assistant.log(`User ${uid} already has active subscription: product=${user.subscription.product.id}, status=${user.subscription.status}, resourceId=${user.subscription.payment?.resourceId}`);
     return assistant.respond('User already has an active subscription', { code: 400 });
   }
 
-  // Check trial eligibility
-  if (trial && user.subscription?.trial?.activated) {
-    return assistant.respond('Trial already used', { code: 400 });
+  // Resolve trial eligibility: if requested but user has subscription history, silently downgrade
+  if (trial) {
+    const historySnapshot = await admin.firestore()
+      .collection('payments-subscriptions')
+      .where('uid', '==', uid)
+      .limit(1)
+      .get();
+
+    if (!historySnapshot.empty) {
+      assistant.log(`User ${uid} not eligible for trial (has subscription history), continuing without trial`);
+      trial = false;
+    }
   }
 
   // Validate product exists in config
-  const product = (Manager.config.products || []).find(p => p.id === productId);
+  const product = (Manager.config.payment?.products || []).find(p => p.id === productId);
   if (!product) {
+    assistant.log(`Product "${productId}" not found (available: ${(Manager.config.payment?.products || []).map(p => p.id).join(', ')})`);
     return assistant.respond(`Product '${productId}' not found`, { code: 400 });
   }
 
-  // Load the provider
-  let provider;
+  assistant.log(`Product resolved: id=${product.id}, name=${product.name}, trialDays=${product.trial?.days || 'none'}`);
+
+  // Load the processor module
+  let processorModule;
   try {
-    provider = require(path.resolve(__dirname, `providers/${processor}.js`));
+    processorModule = require(path.resolve(__dirname, `processors/${processor}.js`));
   } catch (e) {
     return assistant.respond(`Unknown processor: ${processor}`, { code: 400 });
   }
 
-  // Initialize the processor SDK
-  const StripeLib = require('../../../libraries/stripe.js');
-  const stripe = StripeLib.init();
-
-  // Create the intent via the provider
+  // Create the intent via the processor
   let result;
   try {
-    result = await provider.createIntent({
+    result = await processorModule.createIntent({
       uid,
       productId,
       frequency,
       trial,
       config: Manager.config,
-      stripe,
+      Manager,
+      assistant,
     });
   } catch (e) {
+    assistant.log(`Failed to create ${processor} intent: ${e.message}`);
     return assistant.respond(`Failed to create intent: ${e.message}`, { code: 500, sentry: true });
   }
 
+  assistant.log(`${processor} intent created: id=${result.id}, url=${result.url}`);
+
   // Build timestamps
   const now = powertools.timestamp(new Date(), { output: 'string' });
   const nowUNIX = powertools.timestamp(now, { output: 'unix' });
@@ -85,7 +100,7 @@ module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
     },
   });
 
-  assistant.log(`Intent ${result.id} created for user ${uid} (product=${productId}, frequency=${frequency}, trial=${trial})`);
+  assistant.log(`Saved payments-intents/${result.id}: uid=${uid}, product=${productId}, frequency=${frequency}, trial=${trial}`);
 
   return assistant.respond({
     id: result.id,

package/src/manager/routes/payments/intent/{providers → processors}/stripe.js

@@ -1,5 +1,5 @@
 /**
- * Stripe intent provider
+ * Stripe intent processor
  * Creates Stripe Checkout Sessions for subscription purchases
  */
 module.exports = {
@@ -12,12 +12,16 @@ module.exports = {
    * @param {string} options.frequency - 'monthly' or 'annually'
    * @param {boolean} options.trial - Whether to include a trial period
    * @param {object} options.config - BEM config (must contain products array)
-   * @param {object} options.stripe - Initialized Stripe SDK instance
+   * @param {object} options.Manager - Manager instance
    * @returns {object} { id, url, raw }
    */
-  async createIntent({ uid, productId, frequency, trial, config, stripe }) {
+  async createIntent({ uid, productId, frequency, trial, config, Manager, assistant }) {
+    // Initialize Stripe SDK
+    const StripeLib = require('../../../../libraries/stripe.js');
+    const stripe = StripeLib.init();
+
     // Find the product in config
-    const product = (config.products || []).find(p => p.id === productId);
+    const product = (config.payment?.products || []).find(p => p.id === productId);
     if (!product) {
       throw new Error(`Product '${productId}' not found in config`);
     }
@@ -28,9 +32,16 @@ module.exports = {
       throw new Error(`No Stripe price found for ${productId}/${frequency}`);
     }
 
+    // Resolve or create Stripe customer (keyed by uid in metadata)
+    const email = assistant?.getUser()?.auth?.email || null;
+    const customer = await resolveCustomer(stripe, uid, email, assistant);
+
+    assistant?.log(`Stripe checkout: priceId=${priceId}, uid=${uid}, customerId=${customer.id}, trial=${trial}, trialDays=${product.trial?.days || 'none'}`);
+
     // Build session params
     const sessionParams = {
       mode: 'subscription',
+      customer: customer.id,
       line_items: [{
         price: priceId,
         quantity: 1,
@@ -52,11 +63,14 @@ module.exports = {
     // Add trial period if requested
     if (trial && product.trial?.days) {
       sessionParams.subscription_data.trial_period_days = product.trial.days;
+      assistant?.log(`Trial period added: ${product.trial.days} days`);
     }
 
     // Create the checkout session
     const session = await stripe.checkout.sessions.create(sessionParams);
 
+    assistant?.log(`Stripe session created: sessionId=${session.id}, url=${session.url}`);
+
     return {
       id: session.id,
       url: session.url,
@@ -64,3 +78,33 @@ module.exports = {
     };
   },
 };
+
+/**
+ * Find an existing Stripe customer by uid metadata, or create one
+ */
+async function resolveCustomer(stripe, uid, email, assistant) {
+  // Search for existing customer with this uid
+  const search = await stripe.customers.search({
+    query: `metadata['uid']:'${uid}'`,
+    limit: 1,
+  });
+
+  if (search.data.length > 0) {
+    const existing = search.data[0];
+    assistant?.log(`Found existing Stripe customer: ${existing.id}`);
+    return existing;
+  }
+
+  // Create new customer
+  const params = {
+    metadata: { uid },
+  };
+
+  if (email) {
+    params.email = email;
+  }
+
+  const customer = await stripe.customers.create(params);
+  assistant?.log(`Created new Stripe customer: ${customer.id}`);
+  return customer;
+}

package/src/manager/routes/payments/intent/processors/test.js

@@ -0,0 +1,106 @@
+const fetch = require('wonderful-fetch');
+
+/**
+ * Test intent processor
+ * Creates fake Stripe-shaped checkout sessions and auto-fires webhooks
+ * Only available in non-production environments
+ */
+module.exports = {
+  /**
+   * Create a test payment intent
+   * Generates Stripe-shaped data and auto-fires a webhook to trigger the full pipeline
+   *
+   * @param {object} options
+   * @param {string} options.uid - User's UID
+   * @param {string} options.productId - Product ID from config
+   * @param {string} options.frequency - 'monthly' or 'annually'
+   * @param {boolean} options.trial - Whether to include a trial period
+   * @param {object} options.config - BEM config
+   * @param {object} options.Manager - Manager instance
+   * @param {object} options.assistant - Assistant instance
+   * @returns {object} { id, url, raw }
+   */
+  async createIntent({ uid, productId, frequency, trial, config, Manager, assistant }) {
+    // Guard: test processor is not available in production
+    if (assistant.isProduction()) {
+      throw new Error('Test processor is not available in production');
+    }
+
+    // Find the product in config
+    const product = (config.payment?.products || []).find(p => p.id === productId);
+    if (!product) {
+      throw new Error(`Product '${productId}' not found in config`);
+    }
+
+    // Get the price ID for the requested frequency (needed for product resolution in toUnified)
+    const priceId = product.prices?.[frequency]?.stripe;
+    if (!priceId) {
+      throw new Error(`No Stripe price found for ${productId}/${frequency}`);
+    }
+
+    // Generate IDs
+    const timestamp = Date.now();
+    const sessionId = `_test-cs-${timestamp}`;
+    const subscriptionId = `_test-sub-${timestamp}`;
+    const eventId = `_test-evt-${timestamp}`;
+
+    // Map frequency to Stripe interval
+    const interval = frequency === 'annually' ? 'year' : 'month';
+
+    // Build timestamps
+    const now = Math.floor(timestamp / 1000);
+    const periodEnd = frequency === 'annually'
+      ? now + (365 * 86400)
+      : now + (30 * 86400);
+
+    // Build Stripe-shaped subscription object
+    const subscription = {
+      id: subscriptionId,
+      object: 'subscription',
+      status: trial && product.trial?.days ? 'trialing' : 'active',
+      metadata: { uid },
+      plan: { id: priceId, interval },
+      current_period_end: periodEnd,
+      current_period_start: now,
+      start_date: now,
+      cancel_at_period_end: false,
+      cancel_at: null,
+      canceled_at: null,
+      trial_start: null,
+      trial_end: null,
+    };
+
+    // Add trial dates if applicable
+    if (trial && product.trial?.days) {
+      subscription.trial_start = now;
+      subscription.trial_end = now + (product.trial.days * 86400);
+      subscription.current_period_end = subscription.trial_end;
+    }
+
+    // Build Stripe-shaped event
+    const event = {
+      id: eventId,
+      type: 'customer.subscription.created',
+      data: { object: subscription },
+    };
+
+    assistant?.log(`Test intent: sessionId=${sessionId}, subscriptionId=${subscriptionId}, eventId=${eventId}, trial=${!!subscription.trial_start}`);
+
+    // Auto-fire webhook (fire-and-forget — don't block intent response)
+    const webhookUrl = `${Manager.project.apiUrl}/backend-manager/payments/webhook?processor=test&key=${process.env.BACKEND_MANAGER_KEY}`;
+    fetch(webhookUrl, {
+      method: 'POST',
+      response: 'json',
+      body: event,
+      timeout: 15000,
+    }).catch((e) => {
+      assistant?.log(`Test processor auto-webhook failed: ${e.message}`);
+    });
+
+    return {
+      id: sessionId,
+      url: `${config.brand?.url || 'https://example.com'}/payment/confirmation?session=${sessionId}`,
+      raw: { id: sessionId, object: 'checkout.session', subscription: subscriptionId },
+    };
+  },
+};

package/src/manager/routes/payments/webhook/post.js

@@ -3,8 +3,12 @@ const powertools = require('node-powertools');
 
 /**
  * POST /payments/webhook?processor=stripe&key=XXX
- * Receives payment provider webhooks, validates them, and saves to Firestore
+ * Receives payment processor webhooks, validates them, and saves to Firestore
  * The Firestore onWrite trigger handles async processing
+ *
+ * This handler is processor-agnostic. Each processor module defines:
+ *   - parseWebhook(req) — extracts { eventId, eventType, raw, uid }
+ *   - isSupported(eventType) — returns true for events we should process
  */
 module.exports = async ({ assistant, Manager, libraries }) => {
   const { admin } = libraries;
@@ -25,32 +29,41 @@ module.exports = async ({ assistant, Manager, libraries }) => {
     return assistant.respond('Invalid key', { code: 401 });
   }
 
-  // Load the provider
-  let provider;
+  // Load the processor module
+  let processorModule;
   try {
-    provider = require(path.resolve(__dirname, `providers/${processor}.js`));
+    processorModule = require(path.resolve(__dirname, `processors/${processor}.js`));
   } catch (e) {
     return assistant.respond(`Unknown processor: ${processor}`, { code: 400 });
   }
 
-  // Parse the webhook using the provider
+  // Parse the webhook using the processor
   let parsed;
   try {
-    parsed = provider.parseWebhook(assistant.ref.req);
+    parsed = processorModule.parseWebhook(assistant.ref.req);
   } catch (e) {
     return assistant.respond(`Failed to parse webhook: ${e.message}`, { code: 400 });
   }
 
   const { eventId, eventType, raw, uid } = parsed;
 
+  assistant.log(`Parsed webhook: eventId=${eventId}, eventType=${eventType}, uid=${uid || 'null'}`);
+
+  // Let the processor decide if this event type is relevant
+  if (processorModule.isSupported && !processorModule.isSupported(eventType)) {
+    assistant.log(`Ignoring event type: ${eventType}`);
+    return assistant.respond({ received: true, ignored: true });
+  }
+
   // Check for duplicate (skip if already processing/completed)
   const existingDoc = await admin.firestore().doc(`payments-webhooks/${eventId}`).get();
   if (existingDoc.exists) {
     const existingStatus = existingDoc.data()?.status;
     if (existingStatus !== 'failed') {
-      assistant.log(`Webhook ${eventId} already exists with status=${existingStatus}, skipping`);
+      assistant.log(`Duplicate webhook ${eventId}, existing status=${existingStatus}, skipping`);
       return assistant.respond({ received: true, duplicate: true });
     }
+    assistant.log(`Retrying previously failed webhook ${eventId}`);
   }
 
   // Build timestamps
@@ -80,7 +93,7 @@ module.exports = async ({ assistant, Manager, libraries }) => {
     },
   });
 
-  assistant.log(`Webhook ${eventId} saved (type=${eventType}, processor=${processor}, uid=${uid})`);
+  assistant.log(`Saved payments-webhooks/${eventId}: eventType=${eventType}, processor=${processor}, uid=${uid}`);
 
   // Return 200 immediately
   return assistant.respond({ received: true });