Draft implementation of server.on(handle-error, ...)

src/client/mockttp-admin-request-builder.ts

@@ -303,6 +303,44 @@ export class MockttpAdminRequestBuilder {
                         body
                     }
                 }
+            }`,
+            // TODO: This is just a copy of the previous client-error section. Needs to be finished.
+            'handle-error': gql`subscription OnError {
+                failedRequest {
+                    errorCode
+                    request {
+                        id
+                        timingEvents
+                        tags
+                        protocol
+                        httpVersion
+                        method
+                        url
+                        path
+
+                        ${this.schema.typeHasField('ClientErrorRequest', 'rawHeaders')
+                            ? 'rawHeaders'
+                            : 'headers'
+                        }
+
+                        ${this.schema.asOptionalField('ClientErrorRequest', 'remoteIpAddress')},
+                        ${this.schema.asOptionalField('ClientErrorRequest', 'remotePort')},
+                    }
+                    response {
+                        id
+                        timingEvents
+                        tags
+                        statusCode
+                        statusMessage
+
+                        ${this.schema.typeHasField('Response', 'rawHeaders')
+                            ? 'rawHeaders'
+                            : 'headers'
+                        }
+
+                        body
+                    }
+                }
             }`
         }[event];
 
@@ -367,4 +405,4 @@ export class MockttpAdminRequestBuilder {
 
             return mockedEndpoint;
         }
-}
+}

src/mockttp.ts

@@ -19,6 +19,7 @@ import {
 } from "./types";
 import type { RequestRuleData } from "./rules/requests/request-rule";
 import type { WebSocketRuleData } from "./rules/websockets/websocket-rule";
+import { ErrorLike } from "./util/error";
 
 export type PortRange = { startPort: number, endPort: number };
 
@@ -415,6 +416,23 @@ export interface Mockttp {
      */
     on(event: 'client-error', callback: (error: ClientError) => void): Promise<void>;
 
+    /**
+     * Subscribe to hear about requests that fail before successfully sending their
+     * initial parameters (the request line & headers). This will fire for requests
+     * that drop connections early, send invalid or too-long headers, or aren't
+     * correctly parseable in some form.
+     *
+     * This is only useful in some niche use cases, such as logging all requests
+     * seen by the server, independently of the rules defined.
+     *
+     * The callback will be called asynchronously from request handling. This function
+     * returns a promise, and the callback is not guaranteed to be registered until
+     * the promise is resolved.
+     *
+     * @category Events
+     */
+    on(event: 'handle-error', callback: (error: ErrorLike) => void): Promise<void>;
+
     /**
      * Adds the given rules to the server.
      *
@@ -576,7 +594,8 @@ export type SubscribableEvent =
     | 'response'
     | 'abort'
     | 'tls-client-error'
-    | 'client-error';
+    | 'client-error'
+    | 'handle-error';
 
 /**
  * @hidden
@@ -677,4 +696,4 @@ export abstract class AbstractMockttp {
         return new WebSocketRuleBuilder(this.addWebSocketRule);
     }
 
-}
+}

src/server/mockttp-server.ts

@@ -30,7 +30,7 @@ import { ServerMockedEndpoint } from "./mocked-endpoint";
 import { createComboServer } from "./http-combo-server";
 import { filter } from "../util/promise";
 import { Mutable } from "../util/type-utils";
-import { isErrorLike } from "../util/error";
+import { ErrorLike, isErrorLike } from "../util/error";
 import { makePropertyWritable } from "../util/util";
 
 import {
@@ -277,6 +277,7 @@ export class MockttpServer extends AbstractMockttp implements Mockttp {
     public on(event: 'tls-client-error', callback: (req: TlsRequest) => void): Promise<void>;
     public on(event: 'tlsClientError', callback: (req: TlsRequest) => void): Promise<void>;
     public on(event: 'client-error', callback: (error: ClientError) => void): Promise<void>;
+    public on(event: 'handle-error', callback: (error: ErrorLike) => void): Promise<void>;
     public on(event: string, callback: (...args: any[]) => void): Promise<void> {
         this.eventEmitter.on(event, callback);
         return Promise.resolve();
@@ -464,32 +465,37 @@ export class MockttpServer extends AbstractMockttp implements Mockttp {
             }
             result = result || 'responded';
         } catch (e) {
-            if (e instanceof AbortError) {
-                abort();
-
-                if (this.debug) {
-                    console.error("Failed to handle request due to abort:", e);
-                }
-            } else {
-                console.error("Failed to handle request:",
-                    this.debug
-                        ? e
-                        : (isErrorLike(e) && e.message) || e
-                );
+            if (this.eventEmitter.listeners('handle-error').length > 0) {
+                this.eventEmitter.emit('handle-error', e);
+            }
+            else {
+                if (e instanceof AbortError) {
+                    abort();
 
-                // Do whatever we can to tell the client we broke
-                try {
-                    response.writeHead(
-                        (isErrorLike(e) && e.statusCode) || 500,
-                        (isErrorLike(e) && e.statusMessage) || 'Server error'
+                    if (this.debug) {
+                        console.error("Failed to handle request due to abort:", e);
+                    }
+                } else {
+                    console.error("Failed to handle request:",
+                        this.debug
+                            ? e
+                            : (isErrorLike(e) && e.message) || e
                     );
-                } catch (e) {}
 
-                try {
-                    response.end((isErrorLike(e) && e.toString()) || e);
-                    result = result || 'responded';
-                } catch (e) {
-                    abort();
+                    // Do whatever we can to tell the client we broke
+                    try {
+                        response.writeHead(
+                            (isErrorLike(e) && e.statusCode) || 500,
+                            (isErrorLike(e) && e.statusMessage) || 'Server error'
+                        );
+                    } catch (e) {}
+
+                    try {
+                        response.end((isErrorLike(e) && e.toString()) || e);
+                        result = result || 'responded';
+                    } catch (e) {
+                        abort();
+                    }
                 }
             }
         }
@@ -818,4 +824,4 @@ ${await this.suggestRule(request)}`
             response: 'aborted' // These h2 errors get no app-level response, just a shutdown.
         });
     }
-}
+}

src/types.ts

@@ -256,4 +256,4 @@ export interface ProxyEnvConfig {
 // A slightly weird one: this is necessary because we export types that inherit from EventEmitter,
 // so the docs include EventEmitter's methods, which @link to this type, that's otherwise not
 // defined in this module. Reexporting the values avoids warnings for that.
-export type defaultMaxListeners = typeof EventEmitter.defaultMaxListeners;
+export type defaultMaxListeners = typeof EventEmitter.defaultMaxListeners;

src/util/error.ts

@@ -1,3 +1,4 @@
+// A server error
 export type ErrorLike = Partial<Error> & {
     // Various properties we might want to look for on errors:
     code?: string;
@@ -15,4 +16,4 @@ export function isErrorLike(error: any): error is ErrorLike {
         error.code ||
         error.stack
     )
-}
+}