perf: Use Apify-provided environment variables to obtain PPE pricing information

packages/actor-scraper/web-scraper/src/internals/crawler_setup.ts

@@ -885,9 +885,9 @@ export class CrawlerSetup implements CrawlerSetupOptions {
             skipLinksP,
             globalStoreP,
             logP,
-            // eslint-disable-next-line @typescript-eslint/await-thenable
+
             requestQueueP,
-            // eslint-disable-next-line @typescript-eslint/await-thenable
+
             keyValueStoreP,
         ]);
 

packages/apify/src/charging.ts

@@ -94,6 +94,24 @@ export class ChargingManager {
         this.purgeChargingLogDataset = configuration.get('purgeOnStart');
         this.useChargingLogDataset = configuration.get('useChargingLogDataset');
 
+        if (
+            configuration.get('actorPricingInfo') &&
+            configuration.get('chargedEventCounts')
+        ) {
+            this.loadPricingInfo(
+                JSON.parse(
+                    configuration.get('actorPricingInfo'),
+                ) as ActorRunPricingInfo,
+                configuration.get('maxTotalChargeUsd') || Infinity,
+            );
+            this.loadChargedEventCounts(
+                JSON.parse(configuration.get('chargedEventCounts')) as Record<
+                    string,
+                    number
+                >,
+            );
+        }
+
         if (this.useChargingLogDataset && this.isAtHome) {
             throw new Error(
                 'Using the ACTOR_USE_CHARGING_LOG_DATASET environment variable is only supported in a local development environment',
@@ -117,12 +135,47 @@ export class ChargingManager {
         return this.pricingModel === 'PAY_PER_EVENT';
     }
 
+    private loadPricingInfo(
+        pricingInfo: ActorRunPricingInfo | undefined,
+        maxTotalChargeUsd: number,
+    ) {
+        this.pricingModel = pricingInfo?.pricingModel;
+
+        // Load per-event pricing information
+        if (pricingInfo?.pricingModel === 'PAY_PER_EVENT') {
+            for (const [eventName, eventPricing] of Object.entries(
+                pricingInfo.pricingPerEvent.actorChargeEvents,
+            )) {
+                this.pricingInfo[eventName] = {
+                    price: eventPricing.eventPriceUsd,
+                    title: eventPricing.eventTitle,
+                };
+            }
+
+            this.maxTotalChargeUsd = maxTotalChargeUsd;
+        }
+    }
+
+    private loadChargedEventCounts(
+        chargedEventCounts: Record<string, number> | undefined,
+    ) {
+        this.chargingState = {};
+
+        for (const [eventName, chargeCount] of Object.entries(
+            chargedEventCounts ?? {},
+        )) {
+            this.chargingState[eventName] = {
+                chargeCount,
+                totalChargedAmount:
+                    chargeCount * (this.pricingInfo[eventName]?.price ?? 0),
+            };
+        }
+    }
+
     /**
      * Initialize the ChargingManager by loading pricing information and charging state via Apify API.
      */
     async init(): Promise<void> {
-        this.chargingState = {};
-
         // Retrieve pricing information
         if (this.isAtHome) {
             if (this.actorRunId === undefined) {
@@ -131,40 +184,25 @@ export class ChargingManager {
                 );
             }
 
-            const run = await this.apifyClient.run(this.actorRunId).get();
-            if (run === undefined) {
-                throw new Error('Actor run not found');
-            }
-
-            this.pricingModel = run.pricingInfo?.pricingModel;
-
-            // Load per-event pricing information
-            if (run.pricingInfo?.pricingModel === 'PAY_PER_EVENT') {
-                for (const [eventName, eventPricing] of Object.entries(
-                    run.pricingInfo.pricingPerEvent.actorChargeEvents,
-                )) {
-                    this.pricingInfo[eventName] = {
-                        price: eventPricing.eventPriceUsd,
-                        title: eventPricing.eventTitle,
-                    };
+            if (
+                this.chargingState === undefined ||
+                this.pricingModel === undefined
+            ) {
+                const run = await this.apifyClient.run(this.actorRunId).get();
+                if (run === undefined) {
+                    throw new Error('Actor run not found');
                 }
 
-                this.maxTotalChargeUsd =
-                    run.options.maxTotalChargeUsd ?? this.maxTotalChargeUsd;
-            }
-
-            // Load charged event counts
-            for (const [eventName, chargeCount] of Object.entries(
-                run.chargedEventCounts ?? {},
-            )) {
-                this.chargingState[eventName] = {
-                    chargeCount,
-                    totalChargedAmount:
-                        chargeCount * (this.pricingInfo[eventName]?.price ?? 0),
-                };
+                this.loadPricingInfo(
+                    run.pricingInfo,
+                    run.options.maxTotalChargeUsd || Infinity,
+                );
+                this.loadChargedEventCounts(run.chargedEventCounts);
             }
         }
 
+        this.chargingState ??= {};
+
         if (!this.isPayPerEvent || !this.useChargingLogDataset) {
             return;
         }

packages/apify/src/configuration.ts

@@ -39,6 +39,8 @@ export interface ConfigurationOptions extends CoreConfigurationOptions {
     metaOrigin?: (typeof META_ORIGINS)[keyof typeof META_ORIGINS];
     testPayPerEvent?: boolean;
     useChargingLogDataset?: boolean;
+    actorPricingInfo?: string;
+    chargedEventCounts?: string;
 }
 
 /**
@@ -179,6 +181,8 @@ export class Configuration extends CoreConfiguration {
         ACTOR_MAX_TOTAL_CHARGE_USD: 'maxTotalChargeUsd',
         ACTOR_TEST_PAY_PER_EVENT: 'testPayPerEvent',
         ACTOR_USE_CHARGING_LOG_DATASET: 'useChargingLogDataset',
+        APIFY_ACTOR_PRICING_INFO: 'actorPricingInfo',
+        APIFY_CHARGED_ACTOR_EVENT_COUNTS: 'chargedEventCounts',
     };
 
     protected static override INTEGER_VARS = [

test/apify/charging.test.ts

@@ -14,10 +14,16 @@ describe('ChargingManager', () => {
 
     afterEach(async () => {
         await Actor.exit({ exit: false });
+
+        // @ts-expect-error
+        Actor._instance = undefined; // eslint-disable-line no-underscore-dangle
+
         await localStorageEmulator.destroy();
 
         delete process.env.ACTOR_TEST_PAY_PER_EVENT;
         delete process.env.ACTOR_MAX_TOTAL_CHARGE_USD;
+        delete process.env.APIFY_ACTOR_PRICING_INFO;
+        delete process.env.APIFY_CHARGED_ACTOR_EVENT_COUNTS;
     });
 
     describe('charge()', () => {
@@ -40,5 +46,34 @@ describe('ChargingManager', () => {
             expect(zeroResult.eventChargeLimitReached).toBe(false);
             expect(zeroResult.chargedCount).toBe(0);
         });
+
+        test('should charge events when ACTOR_MAX_TOTAL_CHARGE_USD is set to "" (cost-unlimited)', async () => {
+            process.env.ACTOR_MAX_TOTAL_CHARGE_USD = '';
+
+            // Set pricing info via env vars (as if coming from platform)
+            process.env.APIFY_ACTOR_PRICING_INFO = JSON.stringify({
+                pricingModel: 'PAY_PER_EVENT',
+                pricingPerEvent: {
+                    actorChargeEvents: {
+                        foobar: {
+                            eventTitle: 'Foo bar',
+                            eventPriceUsd: 0.1,
+                            eventDescription: 'Foo foo bar bar',
+                        },
+                    },
+                },
+            });
+            process.env.APIFY_CHARGED_ACTOR_EVENT_COUNTS = JSON.stringify({});
+
+            await Actor.init();
+
+            const chargeResult = await Actor.charge({
+                eventName: 'foobar',
+                count: 4,
+            });
+
+            expect(chargeResult.chargedCount).toBe(4);
+            expect(chargeResult.eventChargeLimitReached).toBe(false);
+        });
     });
 });