ghost 6.60.0 → 6.61.0

package/core/server/services/lib/mailgun-client.js

@@ -165,8 +165,8 @@ module.exports = class MailgunClient {
    * @param {Object} mailgunOptions
    * @param {Function} batchHandler
    * @param {Object} options
-   * @param {number} [options.maxEvents] Not a strict maximum. We stop fetching after we reached the maximum AND received at least one event after begin (not equal) to prevent deadlocks.
-   * @returns {Promise<void>}
+   * @param {number} [options.maxEvents] Per-domain soft maximum. We stop fetching a domain after we reached the maximum AND received at least one event after begin (not equal) to prevent deadlocks.
+   * @returns {Promise<{safeCursor?: Date} | void>}
    */
   async fetchEvents(mailgunOptions, batchHandler, { maxEvents = Infinity } = {}) {
     const mailgunInstance = this.getInstance();
@@ -184,12 +184,33 @@ module.exports = class MailgunClient {
     // Determine which domains to fetch from
     const domains = this.#getDomainsToFetch(mailgunConfig);
 
+    const cappedDomainCursors = [];
+
     // Fetch events from each domain
     for (const domain of domains) {
-      await this.#fetchEventsFromDomain(domain, mailgunInstance, mailgunOptions, batchHandler, {
-        maxEvents,
-      });
+      const result = await this.#fetchEventsFromDomain(
+        domain,
+        mailgunInstance,
+        mailgunOptions,
+        batchHandler,
+        { maxEvents },
+      );
+
+      if (
+        result.capped &&
+        result.lastEventTimestamp &&
+        Number.isFinite(result.lastEventTimestamp.getTime())
+      ) {
+        cappedDomainCursors.push(result.lastEventTimestamp);
+      }
     }
+
+    const safeCursor = cappedDomainCursors.reduce(
+      (earliest, cursor) => (!earliest || cursor < earliest ? cursor : earliest),
+      undefined,
+    );
+
+    return { safeCursor };
   }
 
   /**
@@ -220,7 +241,7 @@ module.exports = class MailgunClient {
    * @param {Function} batchHandler
    * @param {Object} options
    * @param {number} options.maxEvents
-   * @returns {Promise<void>}
+   * @returns {Promise<{capped: boolean, eventCount: number, lastEventTimestamp?: Date}>}
    */
   async #fetchEventsFromDomain(
     domain,
@@ -235,6 +256,9 @@ module.exports = class MailgunClient {
 
     let batchCount = 0;
     let totalBatchTime = 0;
+    let eventCount = 0;
+    let lastEventTimestamp;
+    let capped = false;
 
     try {
       let page = await this.getEventsFromMailgun(mailgunInstance, domain, mailgunOptions);
@@ -248,7 +272,6 @@ module.exports = class MailgunClient {
         `[MailgunClient fetchEventsFromDomain ${domain}]: finished fetching first page with ${events.length} events`,
       );
 
-      let eventCount = 0;
       const beginTimestamp = mailgunOptions.begin
         ? Math.ceil(mailgunOptions.begin * 1000)
         : undefined; // ceil here if we have rounding errors
@@ -263,6 +286,13 @@ module.exports = class MailgunClient {
         totalBatchTime += batchDuration;
 
         eventCount += events.length;
+        const batchLastEventTimestamp = events[events.length - 1].timestamp;
+        if (
+          batchLastEventTimestamp &&
+          (!lastEventTimestamp || batchLastEventTimestamp > lastEventTimestamp)
+        ) {
+          lastEventTimestamp = batchLastEventTimestamp;
+        }
 
         if (
           eventCount >= maxEvents &&
@@ -270,6 +300,7 @@ module.exports = class MailgunClient {
             !events[events.length - 1].timestamp ||
             events[events.length - 1].timestamp.getTime() > beginTimestamp)
         ) {
+          capped = true;
           break;
         }
 
@@ -294,10 +325,15 @@ module.exports = class MailgunClient {
       const overallEndTime = Date.now();
       const totalDuration = overallEndTime - overallStartTime;
       const averageBatchTime = batchCount > 0 ? totalBatchTime / batchCount : 0;
+      const cursor = Number.isFinite(lastEventTimestamp?.getTime())
+        ? lastEventTimestamp.toISOString()
+        : 'none';
 
       logging.info(
-        `[MailgunClient fetchEventsFromDomain ${domain}]: Processed ${batchCount} batches in ${(totalDuration / 1000).toFixed(2)}s. Average batch time: ${(averageBatchTime / 1000).toFixed(2)}s`,
+        `[MailgunClient fetchEventsFromDomain ${domain}]: Processed ${eventCount} events in ${batchCount} batches in ${(totalDuration / 1000).toFixed(2)}s. Average batch time: ${(averageBatchTime / 1000).toFixed(2)}s. Status: ${capped ? 'capped' : 'exhausted'}. Cursor: ${cursor}`,
       );
+
+      return { capped, eventCount, lastEventTimestamp };
     } catch (error) {
       logging.error(`[MailgunClient fetchEventsFromDomain ${domain}]: Error fetching events`);
       logging.error(error);

package/core/server/services/media-inliner/external-media-inliner-job.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const job_1 = require("../jobs-service/job");
+class ExternalMediaInlinerJob extends job_1.Job {
+    static type = 'external-media-inliner';
+    domains;
+    constructor({ domains }) {
+        super();
+        this.domains = domains;
+    }
+}
+exports.default = ExternalMediaInlinerJob;

package/core/server/services/media-inliner/external-media-inliner.js

@@ -177,6 +177,96 @@ class ExternalMediaInliner {
     }
   }
 
+  /**
+   * Download and store one external media URL without deciding where it came from
+   * or where its replacement belongs. Callers own discovery and replacement.
+   *
+   * @param {string} sourceUrl
+   * @returns {Promise<import('./types').ExternalMediaImportResult>}
+   */
+  async importUrl(sourceUrl) {
+    let response;
+    try {
+      response = await this.getRemoteMedia(sourceUrl);
+    } catch (error) {
+      return {
+        status: 'failed',
+        sourceUrl,
+        stage: 'download',
+        reason: 'The media file could not be downloaded.',
+        error,
+      };
+    }
+
+    if (!response) {
+      return {
+        status: 'failed',
+        sourceUrl,
+        stage: 'download',
+        reason: 'The media file could not be downloaded.',
+      };
+    }
+
+    let media;
+    try {
+      media = await this.extractFileDataFromResponse(sourceUrl, response);
+    } catch (error) {
+      return {
+        status: 'failed',
+        sourceUrl,
+        stage: 'extract',
+        reason: 'The downloaded media file could not be read.',
+        error,
+      };
+    }
+
+    try {
+      const storedUrl = await this.storeMediaLocally(media);
+      if (!storedUrl) {
+        return {
+          status: 'failed',
+          sourceUrl,
+          stage: 'unsupported',
+          reason: 'No configured storage accepts this media file.',
+        };
+      }
+
+      return {
+        status: 'stored',
+        sourceUrl,
+        storedUrl,
+      };
+    } catch (error) {
+      return {
+        status: 'failed',
+        sourceUrl,
+        stage: 'storage',
+        reason: 'The media file could not be stored in Ghost.',
+        error,
+      };
+    }
+  }
+
+  /**
+   * Convert an import result into the replacement URL expected by the existing
+   * content and field processing. Expected download and unsupported-file failures
+   * return null so the original URL remains unchanged. Results containing an
+   * underlying processing error are rethrown so the established per-resource
+   * catch boundary continues to log and isolate them.
+   *
+   * @param {import('./types').ExternalMediaImportResult} result
+   * @returns {string|null}
+   */
+  #replacementUrlFromImportResult(result) {
+    if (result.status === 'stored') {
+      return result.storedUrl;
+    }
+    if ('error' in result) {
+      throw result.error;
+    }
+    return null;
+  }
+
   static findMatches(content, domain) {
     // NOTE: the src could end with a quote, bracket, apostrophe, double-backslash, or encoded quote.
     //     Backlashes are added to content as an escape character
@@ -208,22 +298,14 @@ class ExternalMediaInliner {
       const matches = this.constructor.findMatches(content, domain);
 
       for (const src of matches) {
-        const response = await this.getRemoteMedia(src);
-
-        let media;
-        if (response) {
-          media = await this.extractFileDataFromResponse(src, response);
-        }
-
-        if (media) {
-          const inlinedSrc = await this.storeMediaLocally(media);
-
-          if (inlinedSrc) {
-            // NOTE: does not account for duplicate images in content
-            //       in those cases would be processed twice
-            content = content.replace(src, inlinedSrc);
-            logging.info(`Inlined media: ${src} -> ${inlinedSrc}`);
-          }
+        const result = await this.importUrl(src);
+        const replacementUrl = this.#replacementUrlFromImportResult(result);
+
+        if (replacementUrl) {
+          // NOTE: does not account for duplicate images in content
+          //       in those cases would be processed twice
+          content = content.replace(src, replacementUrl);
+          logging.info(`Inlined media: ${src} -> ${replacementUrl}`);
         }
       }
     }
@@ -246,20 +328,12 @@ class ExternalMediaInliner {
         const src = resourceModel.get(field);
 
         if (src && src.startsWith(domain)) {
-          const response = await this.getRemoteMedia(src);
-
-          let media;
-          if (response) {
-            media = await this.extractFileDataFromResponse(src, response);
-          }
-
-          if (media) {
-            const inlinedSrc = await this.storeMediaLocally(media);
+          const result = await this.importUrl(src);
+          const replacementUrl = this.#replacementUrlFromImportResult(result);
 
-            if (inlinedSrc) {
-              updatedFields[field] = inlinedSrc;
-              logging.info(`Added media to inline: ${src} -> ${inlinedSrc}`);
-            }
+          if (replacementUrl) {
+            updatedFields[field] = replacementUrl;
+            logging.info(`Added media to inline: ${src} -> ${replacementUrl}`);
           }
         }
       }

package/core/server/services/media-inliner/service.js

@@ -1,10 +1,11 @@
+const errors = require('@tryghost/errors');
+
+let instance;
+
 module.exports = {
   async init() {
-    const debug = require('@tryghost/debug')('mediaInliner');
     const MediaInliner = require('./external-media-inliner');
-    const logging = require('@tryghost/logging');
     const models = require('../../models');
-    const jobsService = require('../jobs');
     const adapterManager = require('../../services/adapter-manager').default;
 
     const mediaStorage = adapterManager.getAdapter('storage:media');
@@ -31,45 +32,16 @@ module.exports = {
       },
     });
 
-    this.api = {
-      startMediaInliner: async (domains) => {
-        if (!domains || !domains.length) {
-          // default domains to inline from if none are provided
-          domains = ['https://s3.amazonaws.com/revue', 'https://substackcdn.com'];
-        }
-
-        debug('[Inliner] Starting media inlining job for domains: ', domains);
+    instance = mediaInliner;
+  },
 
-        // @NOTE: the job is "inline" (aka non-offloaded into a thread), because usecases are currently
-        //        limited to migrational, so there is no expectations for site's availability etc.
-        logging.info('[Background Job] external-media-inliner queued');
-        await jobsService.addJob({
-          name: 'external-media-inliner',
-          job: async (data) => {
-            const startedAt = Date.now();
-            logging.info('[Background Job] external-media-inliner started');
-            try {
-              const result = await mediaInliner.inline(data.domains);
-              logging.info(
-                `[Background Job] external-media-inliner completed in ${Date.now() - startedAt}ms`,
-              );
-              return result;
-            } catch (err) {
-              logging.error(
-                err,
-                `[Background Job] external-media-inliner failed after ${Date.now() - startedAt}ms`,
-              );
-              throw err;
-            }
-          },
-          data: { domains },
-          offloaded: false,
-        });
+  getInstance() {
+    if (!instance) {
+      throw new errors.IncorrectUsageError({
+        message: 'Media inliner used before init(). Call init() from boot first.',
+      });
+    }
 
-        return {
-          status: 'success',
-        };
-      },
-    };
+    return instance;
   },
 };

package/core/server/services/media-inliner/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/server/services/members/import-export/export/exporter.js

@@ -54,14 +54,14 @@ class MembersCSVExporter {
         const hasFilter = options.limit !== 'all' || options.filter || options.search;
         const ids = hasFilter ? await this._members.findFilteredIds(options) : null;
         if (ids) {
-            logging.info(`[MembersExporter] Found ${ids.length} members matching filter criteria`);
+            logging.info({ event: { name: 'members-export.filtered' }, matched: ids.length }, 'Found members matching the export filter');
         }
         const reference = await this.fetchReferenceData();
         const membersQuery = this._knex('members').select(...MEMBER_COLUMNS);
         if (ids) {
             membersQuery.whereIn('id', ids);
         }
-        logging.info('[MembersExporter] Starting streaming export of members');
+        logging.info({ event: { name: 'members-export.started' } }, 'Starting streaming export of members');
         const batchingTransform = this.createBatchingTransform();
         const processingTransform = this.createProcessingTransform(reference);
         (0, node_stream_1.pipeline)(membersQuery.stream(), batchingTransform, processingTransform, (err) => {
@@ -69,9 +69,7 @@ class MembersCSVExporter {
                 logging.error({ event: { name: 'members-export.stream.error' }, err }, 'Members export stream failed');
             }
             else {
-                logging.info('[MembersExporter] Total time taken for member export: ' +
-                    (Date.now() - start) / 1000 +
-                    's');
+                logging.info({ event: { name: 'members-export.completed' }, durationMs: Date.now() - start }, 'Members export completed');
             }
         });
         return processingTransform;
@@ -95,7 +93,7 @@ class MembersCSVExporter {
             acc[label.id] = label.name;
             return acc;
         }, {}));
-        logging.info('[MembersExporter] Fetched products and labels in ' + (Date.now() - start) + 'ms');
+        logging.info({ event: { name: 'members-export.reference_data_read' }, durationMs: Date.now() - start }, 'Read the products and labels an export names');
         const activeCustomFields = await this._customFields.activeDefinitions();
         return { allProducts, allLabels, activeCustomFields };
     }

package/core/server/services/members/import-export/import/importer.js

@@ -17,6 +17,7 @@ const messages = {
     giftCannotCombineWithImportTier: 'Cannot specify both gift_id and import_tier.',
     giftCannotCombineWithComplimentary: 'Cannot specify both gift_id and complimentary_plan.',
     giftReassignFailed: 'Failed to reassign gift to member.',
+    customFieldWriteFailed: 'Failed to save the custom field values for this member.',
 };
 // Columns whose presence makes a row slow to import (they reach out to Stripe), so
 // a file carrying any of them is deferred regardless of size. The routing decision
@@ -90,7 +91,7 @@ class MembersCSVImporter {
         // a request without a user actually reaches the deferred path.
         const emailRecipient = requestUserEmail ?? (await this._email.getDefaultRecipient());
         const spooled = await this._spool.write(rows);
-        logging.info('[Background Job] members-import queued');
+        logging.info({ event: { name: 'members.import.queued' }, rows: rows.length }, 'Members import queued');
         this._addJob({
             job: () => this.runImportJob(spooled, { labelName, extraLabels, emailRecipient }, verificationTrigger),
             offloaded: false,
@@ -101,7 +102,7 @@ class MembersCSVImporter {
     // in the job itself, and there is no retry behind it.
     async runImportJob(spooled, { labelName, extraLabels, emailRecipient, }, verificationTrigger) {
         const startedAt = Date.now();
-        logging.info('[Background Job] members-import started');
+        logging.info({ event: { name: 'members.import.started' } }, 'Members import started');
         // Null until the import produces one: parsing and mapping already happened inside
         // the request, so anything failing from here is ours rather than the file's.
         let result = null;
@@ -125,10 +126,15 @@ class MembersCSVImporter {
             links: this._email.links,
         })));
         if (result) {
-            logging.info(`[Background Job] members-import completed in ${Date.now() - startedAt}ms: imported ${result.imported}, ${result.errors.length} row(s) rejected`);
+            logging.info({
+                event: { name: 'members.import.completed' },
+                durationMs: Date.now() - startedAt,
+                imported: result.imported,
+                rejected: result.errors.length,
+            }, 'Members import completed');
         }
         else {
-            logging.info(`[Background Job] members-import failed after ${Date.now() - startedAt}ms`);
+            logging.info({ event: { name: 'members.import.failed' }, durationMs: Date.now() - startedAt }, 'Members import failed');
         }
     }
     // Only the write itself may throw. Callers rely on that to tell an import that never
@@ -300,7 +306,17 @@ class MembersCSVImporter {
                     }
                 }
                 // On the row's transaction, so the values commit or roll back with the member.
-                await this._customFields.applyWrite(member.id, customFieldPlan, trx);
+                try {
+                    await this._customFields.applyWrite(member.id, customFieldPlan, trx);
+                }
+                catch (writeError) {
+                    // planWrite passed every value before the transaction opened, so a failure
+                    // here is ours and not the row's. Operators get the original, which a driver
+                    // will have written a query into; the publisher gets a sentence instead, in a
+                    // file they open next to a spreadsheet.
+                    this._report(writeError);
+                    throw new errors.DataImportError({ message: tpl(messages.customFieldWriteFailed) });
+                }
                 await trx.commit();
                 imported += 1;
             }

package/core/server/services/members/import-export/import/stripe-utils.js

@@ -175,7 +175,12 @@ module.exports = class MembersCSVImporterStripeUtils {
           await this.archivePrice(newStripePrice.id);
         } catch (archiveErr) {
           logging.warn(
-            `Failed to archive orphaned Stripe price ${newStripePrice.id} after a failed subscription update: ${archiveErr.message}`,
+            {
+              event: { name: 'members.import.orphaned_price_archive_failed' },
+              err: archiveErr,
+              stripePriceId: newStripePrice.id,
+            },
+            'Failed to archive an orphaned Stripe price after a failed subscription update',
           );
         }
         throw err;

package/core/server/services/members/import-export/index.js

@@ -63,7 +63,12 @@ function makeImporter(deps) {
     const customFields = {
         activeFields: async () => labs.isSet('membersCustomFields') ? deps.customFields.definitions.browse() : [],
         planWrite: (values) => deps.customFields.values.planWrite(values),
-        applyWrite: (memberId, plan, executor) => deps.customFields.values.applyWrite(memberId, plan, { executor }),
+        // Every value the import writes came out of the file, whichever column carried it.
+        // An import has no id to give until runs are tracked, so it names its kind only.
+        applyWrite: (memberId, plan, executor) => deps.customFields.values.applyWrite(memberId, plan, {
+            writtenBy: { type: 'import', id: null },
+            executor,
+        }),
     };
     // Inline jobs never reach the job manager's Sentry handler, which is wired to the
     // offloaded worker path only, so a throw here would be seen by nobody.

package/core/server/services/members/members-api/members-api.js

@@ -179,6 +179,11 @@ module.exports = function MembersAPI({
     offersAPI,
     stripeAPIService,
     settingsCache,
+    // The service wrapper, not the checkout config it builds: tiers and members are
+    // initialised in the same Promise.all, so reading the property here would capture
+    // whatever it was before tiers finished — usually undefined.
+    tiersService,
+    labsService,
   });
 
   const memberController = new MemberController({

package/core/server/services/members/members-api/services/member-bread-service.js

@@ -9,6 +9,8 @@ const messages = {
   memberNotFound: 'Member not found.',
   customFieldsOnAdd:
     'Custom field values cannot be set while creating a member. Create the member, then set values with an edit.',
+  customFieldsWithoutWriter:
+    'Custom field values cannot be set by a request with no authenticated user or integration.',
 };
 
 // Stored in the action's `context.action_name`; Admin maps it to a display label.
@@ -654,7 +656,23 @@ module.exports = class MemberBREADService {
     }
 
     if (plannedCustomFields) {
-      await this.customFieldValues.applyWrite(model.id, plannedCustomFields);
+      // Every value reaching here was typed into the Admin API, so the writer is
+      // whoever made the request — the same pair the action log records, so the two
+      // agree about who did it rather than one saying only that it was "admin".
+      //
+      // The only route to this branch is the authenticated Admin API, so an anonymous
+      // request is a mistake somewhere upstream rather than a writer to invent a name
+      // for. Refusing keeps every stored writer resolvable.
+      const context = options.context || {};
+      if (!context.integration && !context.user) {
+        throw new errors.IncorrectUsageError({
+          message: tpl(messages.customFieldsWithoutWriter),
+        });
+      }
+      const writtenBy = context.integration
+        ? { type: 'integration', id: context.integration.id }
+        : { type: 'user', id: context.user };
+      await this.customFieldValues.applyWrite(model.id, plannedCustomFields, { writtenBy });
 
       // Custom fields aren't a member column or relation, so an edit touching
       // only them leaves `model._changed` empty and the save fires nothing.

package/core/server/services/members/members-api/services/payments-service.js

@@ -14,6 +14,8 @@ class PaymentsService {
    * @param {import('../../../offers/application/offers-api')} deps.offersAPI
    * @param {import('../../../stripe/stripe-api')} deps.stripeAPIService
    * @param {{get(key: string): any}} deps.settingsCache
+   * @param {{checkout: import('../../../tier-checkout-config').TierCheckoutConfigService}} deps.tiersService
+   * @param {{isSet(flag: string): boolean}} deps.labsService
    */
   constructor(deps) {
     /** @private */
@@ -30,6 +32,10 @@ class PaymentsService {
     this.stripeAPIService = deps.stripeAPIService;
     /** @private */
     this.settingsCache = deps.settingsCache;
+    /** @private */
+    this.tiersService = deps.tiersService;
+    /** @private */
+    this.labsService = deps.labsService;
     DomainEvents.subscribe(OfferCreatedEvent, async (event) => {
       await this.getCouponForOffer(event.data.offer.id);
     });
@@ -114,11 +120,19 @@ class PaymentsService {
     const price = await this.getPriceForTierCadence(tier, cadence);
 
     const data = {
-      metadata,
+      // The tier being bought, recorded on the session so the completed event can find
+      // the configuration that produced its questions. Nothing else carries it: a
+      // completed session names prices and products, and mapping those back is a
+      // lookup that can fail where this cannot.
+      metadata: { ...metadata, ghostTierId: tier.id.toHexString() },
       successUrl: successUrl,
       cancelUrl: cancelUrl,
       trialDays: trialDays ?? tier.trialDays,
       coupon: coupon?.id,
+      // Resolved here rather than cached with the tier, so a field archived a minute
+      // ago stops being asked on the next checkout. A failure to resolve must not
+      // stop a member paying, so it costs the questions and nothing else.
+      checkout: await this.getCheckoutConfigForTier(tier),
     };
 
     // If we already have a coupon, we don't want to give trial days over it
@@ -135,6 +149,38 @@ class PaymentsService {
     return session.url;
   }
 
+  /**
+   * What this tier's checkout should ask for beyond the payment, or nothing.
+   *
+   * Undefined on every path but the configured one, including the flag being off: the
+   * session builder adds no parameters for it, so an unconfigured site's request to
+   * Stripe is exactly the request it made before this existed.
+   *
+   * @private
+   * @param {import('../../../tiers/tier')} tier
+   */
+  async getCheckoutConfigForTier(tier) {
+    const checkoutConfig = this.tiersService?.checkout;
+    if (!this.labsService?.isSet('membersCustomFields') || !checkoutConfig) {
+      return undefined;
+    }
+    try {
+      return await checkoutConfig.resolve(tier.id.toHexString());
+    } catch (err) {
+      // A checkout that asks one fewer question still takes the money; one that fails
+      // to be created takes none. This is the whole reason it is caught.
+      logging.error(
+        {
+          event: { name: 'stripe_checkout.tier_config.resolve_failed' },
+          err,
+          tierId: tier.id.toHexString(),
+        },
+        'Failed to resolve what a tier checkout should collect',
+      );
+      return undefined;
+    }
+  }
+
   /**
    * @param {object} params
    * @param {Member} [params.member]

package/core/server/services/members-custom-fields/actions.js

@@ -3,8 +3,27 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.actingContext = actingContext;
 exports.recordCustomFieldAction = recordCustomFieldAction;
 const logging_1 = __importDefault(require("@tryghost/logging"));
+/**
+ * Who is acting, read off an API frame's context.
+ *
+ * Here rather than in each endpoint, because two resources now record custom field history
+ * and a second reading of the same shape is a second chance to disagree about it. An
+ * integration and a user are both actors; a request that is neither — a webhook, a job —
+ * has none, and the history says so rather than guessing.
+ */
+function actingContext(context) {
+    const frame = (context ?? {});
+    if (frame.integration) {
+        return { actor: { id: frame.integration.id, type: 'integration' } };
+    }
+    if (frame.user) {
+        return { actor: { id: frame.user, type: 'user' } };
+    }
+    return { actor: null };
+}
 // Field-definition changes map to activity-feed events. A field's timeline reads
 // added -> edited -> archived -> restored, and a permanent delete (only from the
 // archived state) ends it with deleted.
@@ -35,6 +54,13 @@ async function recordCustomFieldAction({ Action, context, verb, subject, details
         }, { autoRefresh: false });
     }
     catch (err) {
-        logging_1.default.error(err);
+        logging_1.default.error({
+            event: { name: 'members.custom_fields.action_log_failed' },
+            err,
+            verb,
+            subject,
+            actorType: context.actor.type,
+            actorId: context.actor.id,
+        }, 'Failed to record a member custom field action');
     }
 }