Minimize server output

[TommySorensen]

Is there anyway to minimize the server output in the log when endpoints fails on SSR? It's flooding my terminal when stuff fails with 404, which in my case means a page does not exist on an api call to an CMS.

"small" output from a single 404 in terminal:

HTTPError: Request failed with status code 404 Not Found
    at fn (file:///blablabla/distribution/core/Ky.js:126:29)
    at process.processTicksAndRejections (node:internal/process/task_queues:95:5)
    at async Ky._retry (file:///blablabla/node_modules/.pnpm/ky@0.31.3/node_modules/ky/distribution/core/Ky.js:205:20)
    at async result.<computed> [as json] (file:///blablabla/node_modules/.pnpm/ky@0.31.3/node_modules/ky/distribution/core/Ky.js:152:39) {
  response: Response {
    [Symbol(realm)]: null,
    [Symbol(state)]: {
      aborted: false,
      rangeRequested: false,
      timingAllowPassed: true,
      requestIncludesCredentials: true,
      type: 'default',
      status: 404,
      timingInfo: [Object],
      cacheState: '',
      statusText: 'Not Found',
      headersList: [HeadersList],
      urlList: [Array],
      body: [Object]
    },
    [Symbol(headers)]: HeadersList {
      [Symbol(headers map)]: [Map],
      [Symbol(headers map sorted)]: null
    }
  },
  request: Request {
    [Symbol(realm)]: { settingsObject: {} },
    [Symbol(state)]: {
      method: 'GET',
      localURLsOnly: false,
      unsafeRequest: false,
      body: null,
      client: {},
      reservedClient: null,
      replacesClientId: '',
      window: 'client',
      keepalive: false,
      serviceWorkers: 'all',
      initiator: '',
      destination: '',
      priority: null,
      origin: 'client',
      policyContainer: 'client',
      referrer: 'client',
      referrerPolicy: '',
      mode: 'cors',
      useCORSPreflightFlag: false,
      credentials: 'same-origin',
      useCredentials: false,
      cache: 'default',
      redirect: 'follow',
      integrity: '',
      cryptoGraphicsNonceMetadata: '',
      parserMetadata: '',
      reloadNavigation: false,
      historyNavigation: false,
      userActivation: false,
      taintedOrigin: false,
      redirectCount: 0,
      responseTainting: 'basic',
      preventNoCacheCacheControlHeaderModification: false,
      done: false,
      timingAllowFailed: false,
      headersList: [HeadersList],

[sholladay]

I would recommend modifying the error in a beforeError hook.

Here are two approaches that come to mind:

1. Simply delete the request and response properties on the error, if you don't need them. That's what most of the output is.

   import ky from 'ky';
   
   await ky('https://example.com', {
       hooks: {
           beforeError: [
               (error) => {
                   delete error.request;
                   delete error.response;
                   return error;
               }
           ]
       }
   });

2. Attach a custom inspect method to the error. This might be considered a cleaner and more appropriate solution, but it's nonstandard and proprietary to Node.js. Some other environments do have equivalents, though, such as Deno.customInspect in Deno.

   import ky from 'ky';
   
   await ky('https://example.com', {
       hooks: {
           beforeError: [
               (error) => {
                   error[util.inspect.custom] = () => {
                       return error.stack;
                   };
                   return error;
               }
           ]
       }
   });

[TommySorensen]

@sholladay Sounds like a great solution. I tried with something like your util example but couldn't really find a good solution since i also need this to run on client side. Do you have a more concrete example?

The delete method is actually okay, but not working since ky expect status to be there, so it throws Cannot read properties of undefined (reading 'status')

[sholladay]

i also need this to run on client side. Do you have a more concrete example?

We can prevent the browser from throwing an error by using Symbol.for() to dynamically get the custom inspect symbol. It will basically be a no-op in the browser (technically it will create a symbol), but I will function as expected in Node.

import ky from 'ky';

const customInspect = Symbol.for('nodejs.util.inspect.custom');

await ky('https://example.com', {
    hooks: {
        beforeError: [
            (error) => {
                error[customInspect] = () => {
                    return error.stack;
                };
                return error;
            }
        ]
    }
});

ky expect status to be there, so it throws Cannot read properties of undefined (reading 'status')

That's interesting. Ky's internals aren't supposed to rely on error.response existing, because the network can error without returning a response. Ky expecting error.request to be there would be more reasonable, but I'd still argue that we should use ?. optional chaining when accessing it internally. If you provide the full error stack, I wouldn't mind taking a look to see where Ky is expecting error.response to exist.

[TommySorensen]

@sholladay I ended up with just throwing errors myself with something like this. My HTTPException is just a class extending Error.
It does the job and i can now do instanceof to check what the error was and the error only contains the response. The output is not only 1/4 of before where everything was passed to HTTPError. Thx for helping

const searchParams = new URLSearchParams();
searchParams.set('url', path);

ky
  .get(url, {
    searchParams,
    throwHttpErrors: false,
    hooks: {
      afterResponse: [
        (request, options, response) => {
          if (!response.ok) {
            const HTTPException = exceptions[response.status];
  
            if (HTTPException) {
              throw new HTTPException(response);
            }

            throw new HTTPError(response, request, options);
          }

          return response;
        },
      ],
    },
  })
  .json();
    
const exceptions = {
  404: PageNotFoundError,
  400: SomeOtherError,
};