WIP: skip trackResponse overhead when there are no listeners

Author: pimterry

src/rules/requests/request-rule.ts

@@ -44,6 +44,7 @@ export class RequestRule implements RequestRule {
 
     public id: string;
     public readonly priority: number;
+    public readonly needsResponseTracking: boolean;
     public requests: Promise<CompletedRequest>[] = [];
     public requestCount = 0;
 
@@ -54,6 +55,7 @@ export class RequestRule implements RequestRule {
         this.priority = data.priority ?? RulePriority.DEFAULT;
         this.matchers = data.matchers;
         this.completionChecker = data.completionChecker;
+        this.needsResponseTracking = data.steps.some(s => s.needsResponseTracking);
 
         this.steps = data.steps.map(<S extends RequestStepDefinition>(stepDefinition: S, i: number) => {
             const StepImplClass = StepLookup[stepDefinition.type];

src/rules/requests/request-step-definitions.ts

@@ -68,6 +68,7 @@ the serialized output from the serialize() methods defined here and creates a wo
  */
 export interface RequestStepDefinition extends Explainable, Serializable {
     type: keyof typeof StepDefinitionLookup;
+    readonly needsResponseTracking?: boolean;
 }
 
 export type SerializedBuffer = { type: 'Buffer', data: number[] };
@@ -1093,6 +1094,10 @@ export class WebhookStep extends Serializable implements RequestStepDefinition {
     readonly type = 'webhook';
     static readonly isFinal = false;
 
+    get needsResponseTracking() {
+        return this.events.includes('response');
+    }
+
     constructor(
         public readonly url: string,
         public readonly events: RequestWebhookEvents[]

src/server/mockttp-server.ts

@@ -113,6 +113,7 @@ export class MockttpServer extends AbstractMockttp implements Mockttp {
 
     private requestRuleSets: { [priority: number]: RequestRule[] } = {};
     private webSocketRuleSets: { [priority: number]: WebSocketRule[] } = {};
+    private rulesNeedResponseTracking: boolean = false;
 
     private httpsOptions: MockttpHttpsOptions | undefined;
     private isHttp2Enabled: boolean | 'fallback';
@@ -287,6 +288,7 @@ export class MockttpServer extends AbstractMockttp implements Mockttp {
 
         const rules = ruleData.map((ruleDatum) => new RequestRule(ruleDatum));
         this.requestRuleSets = _.groupBy(rules, r => r.priority);
+        this.rulesNeedResponseTracking = rules.some(r => r.needsResponseTracking);
 
         return Promise.resolve(rules.map(r => new ServerMockedEndpoint(r)));
     }
@@ -295,6 +297,7 @@ export class MockttpServer extends AbstractMockttp implements Mockttp {
         return Promise.resolve(ruleData.map((ruleDatum) => {
             const rule = new RequestRule(ruleDatum);
             this.addToRuleSets(this.requestRuleSets, rule);
+            if (rule.needsResponseTracking) this.rulesNeedResponseTracking = true;
             return new ServerMockedEndpoint(rule);
         }));
     }
@@ -384,6 +387,47 @@ export class MockttpServer extends AbstractMockttp implements Mockttp {
         });
     }
 
+    private prepareResponse(
+        rawResponse: http.ServerResponse,
+        request: OngoingRequest
+    ): { response: OngoingResponse, hasResponseListener: boolean } {
+        const hasResponseListener = this.eventEmitter.listenerCount('response') > 0;
+        const needsResponseTracking = hasResponseListener
+            || this.eventEmitter.listenerCount('response-initiated') > 0
+            || this.eventEmitter.listenerCount('response-body-data') > 0
+            || this.eventEmitter.listenerCount('abort') > 0 // Abort events include response timing data
+            || this.rulesNeedResponseTracking;
+
+        let response: OngoingResponse;
+        if (needsResponseTracking) {
+            response = trackResponse(
+                rawResponse,
+                request.timingEvents,
+                request.tags,
+                {
+                    maxSize: this.maxBodySize,
+                    onWriteHead: () => this.announceInitialResponseAsync(response),
+                    onBodyData: this.eventEmitter.listenerCount('response-body-data') > 0
+                        ? this.announceBodyDataAsync.bind(this, 'response')
+                        : undefined
+                }
+            );
+            if (hasResponseListener) {
+                // Start buffering response body if there's somebody who
+                // might want to hear about it later
+                response.body.asBuffer().catch(() => {});
+            }
+        } else {
+            // When no response-related events are registered, skip the tracking overhead
+            // (PassThrough stream creation, write/writeHead/end interception)
+            response = rawResponse as OngoingResponse;
+            response.timingEvents = request.timingEvents;
+            response.tags = request.tags;
+        }
+
+        return { response, hasResponseListener };
+    }
+
     private announceInitialRequestAsync(request: OngoingRequest) {
         if (this.eventEmitter.listenerCount('request-initiated') === 0) return;
 
@@ -698,24 +742,7 @@ export class MockttpServer extends AbstractMockttp implements Mockttp {
 
         this.announceInitialRequestAsync(request);
 
-        const response = trackResponse(
-            rawResponse,
-            request.timingEvents,
-            request.tags,
-            {
-                maxSize: this.maxBodySize,
-                onWriteHead: () => this.announceInitialResponseAsync(response),
-                onBodyData: this.eventEmitter.listenerCount('response-body-data') > 0
-                    ? this.announceBodyDataAsync.bind(this, 'response')
-                    : undefined
-            }
-        );
-        const hasResponseListener = this.eventEmitter.listenerCount('response') > 0;
-        if (hasResponseListener) {
-            // Start buffering response body if there's somebody who
-            // might want to hear about it later
-            response.body.asBuffer().catch(() => {});
-        }
+        const { response, hasResponseListener } = this.prepareResponse(rawResponse, request);
 
         response.id = request.id;
         response.on('error', (error) => {