@defra/lis-infra-ui-services 0.36.0 → 0.37.0

package/README.md

@@ -180,6 +180,8 @@ The main entry point (`@defra/lis-infra-ui-services`) exports `buildMicrositePat
 | 503           | `service-unavailable`  |
 | anything else | `problem-with-service` |
 
+5xx responses are logged at `error`, and 4xx responses other than 401, 403 and 404 at `warn`, each with the error object, request method, path and status code. Boom messages are logged, so application code must not put user-supplied text in them.
+
 ```js
 import { catchAll } from '@defra/lis-infra-ui-services/errors'
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra/lis-infra-ui-services",
-  "version": "0.36.0",
+  "version": "0.37.0",
   "description": "UI-Services shared definitions for the livestock taxonomy topology.",
   "main": "src/index.js",
   "repository": {

package/src/errors/index.js

@@ -28,16 +28,56 @@ function getStatusCode(response) {
   return response?.statusCode ?? response?.output?.statusCode
 }
 
-function getLogMessage(response, statusCode) {
+const routineClientErrors = new Set([
+  statusCodes.notFound,
+  statusCodes.unauthorized,
+  statusCodes.forbidden
+])
+
+function getError(response, statusCode) {
+  const error = response?.source instanceof Error ? response.source : response
+  if (error instanceof Error) {
+    return error
+  }
+  if (typeof response?.source?.message === 'string') {
+    return new Error(response.source.message)
+  }
+  return new Error(`Request failed with status ${statusCode}`)
+}
+
+function isLoggableClientError(response, statusCode) {
   return (
-    response?.stack ??
-    response?.message ??
-    response?.source?.stack ??
-    response?.source?.message ??
-    `Request failed with status ${statusCode}`
+    response?.isBoom === true &&
+    statusCode >= statusCodes.badRequest &&
+    statusCode < statusCodes.internalServerError &&
+    !routineClientErrors.has(statusCode)
   )
 }
 
+function logFailure(request, statusCode) {
+  const { response } = request
+  const isServerError =
+    statusCode >= statusCodes.internalServerError &&
+    !isAnsweredByMaintenance(request)
+
+  if (!isServerError && !isLoggableClientError(response, statusCode)) {
+    return
+  }
+
+  // Keys mirror hapi-pino's shape because the CDP pipeline maps them to ECS fields and drops the rest; request.path deliberately omits the query string
+  const context = {
+    err: getError(response, statusCode),
+    req: { method: request.method, url: request.path },
+    res: { statusCode }
+  }
+
+  if (isServerError) {
+    logger.error(context, 'Request failed')
+  } else {
+    logger.warn(context, 'Request rejected')
+  }
+}
+
 /**
  * @param {Request} request
  * @param {ResponseToolkit} h
@@ -47,12 +87,7 @@ export function catchAll(request, h) {
   const { response } = request
   const statusCode = getStatusCode(response)
 
-  if (
-    statusCode >= statusCodes.internalServerError &&
-    !isAnsweredByMaintenance(request)
-  ) {
-    logger.error(getLogMessage(response, statusCode))
-  }
+  logFailure(request, statusCode)
 
   if (!('isBoom' in response)) {
     return h.continue

package/src/errors/index.test.js

@@ -1,10 +1,10 @@
 import assert from 'node:assert/strict'
-import { afterEach, test, vi } from 'vitest'
+import { afterEach, expect, test, vi } from 'vitest'
 
 import { statusCodes } from '../status-codes.js'
 
 const { logger } = vi.hoisted(() => ({
-  logger: { error: vi.fn() }
+  logger: { error: vi.fn(), warn: vi.fn() }
 }))
 
 vi.mock('@defra/lis-hubs-infra-core', () => ({ logger }))
@@ -23,13 +23,11 @@ function createToolkit() {
   return toolkit
 }
 
-function createBoomRequest(statusCode) {
+function createBoomRequest(statusCode, error = new Error('Mock error')) {
   return {
-    response: {
-      isBoom: true,
-      stack: 'Mock error stack',
-      output: { statusCode }
-    }
+    method: 'get',
+    path: '/mock-path',
+    response: Object.assign(error, { isBoom: true, output: { statusCode } })
   }
 }
 
@@ -106,19 +104,54 @@ test('catchAll logs server errors and renders the problem with the service page'
   assert.deepEqual(toolkit.code.mock.calls[0], [
     statusCodes.internalServerError
   ])
-  assert.deepEqual(logger.error.mock.calls[0], ['Mock error stack'])
+  assert.deepEqual(logger.error.mock.calls[0], [
+    {
+      err: request.response,
+      req: { method: 'get', url: '/mock-path' },
+      res: { statusCode: statusCodes.internalServerError }
+    },
+    'Request failed'
+  ])
+  assert.equal(logger.warn.mock.calls.length, 0)
 })
 
-test('catchAll does not log client errors', () => {
+test.each([statusCodes.badRequest, statusCodes.unprocessableEntity])(
+  'catchAll warns about a %i with the error',
+  (statusCode) => {
+    // Arrange
+    const request = createBoomRequest(statusCode, new Error('Invalid input'))
+    const toolkit = createToolkit()
+
+    // Act
+    catchAll(request, toolkit)
+
+    // Assert
+    assert.deepEqual(logger.warn.mock.calls[0], [
+      {
+        err: request.response,
+        req: { method: 'get', url: '/mock-path' },
+        res: { statusCode }
+      },
+      'Request rejected'
+    ])
+    assert.equal(logger.error.mock.calls.length, 0)
+  }
+)
+
+test.each([
+  statusCodes.notFound,
+  statusCodes.unauthorized,
+  statusCodes.forbidden
+])('catchAll does not log a routine %i', (statusCode) => {
   // Arrange
-  const request = createBoomRequest(statusCodes.notFound)
-  const toolkit = createToolkit()
+  const request = createBoomRequest(statusCode)
 
   // Act
-  catchAll(request, toolkit)
+  catchAll(request, createToolkit())
 
   // Assert
   assert.equal(logger.error.mock.calls.length, 0)
+  assert.equal(logger.warn.mock.calls.length, 0)
 })
 
 test('catchAll prefers a client-attached statusCode over a boomified 500', () => {
@@ -127,7 +160,6 @@ test('catchAll prefers a client-attached statusCode over a boomified 500', () =>
     response: {
       isBoom: true,
       statusCode: statusCodes.notFound,
-      stack: 'Mock error stack',
       output: { statusCode: statusCodes.internalServerError }
     }
   }
@@ -161,15 +193,16 @@ test('catchAll does not log the 503 the maintenance plugin answered with', () =>
   assert.equal(logger.error.mock.calls.length, 0)
 })
 
-test('catchAll logs plain 500 responses before continuing', () => {
+test('catchAll logs the error behind plain 500 responses before continuing', () => {
   // Arrange
   const toolkit = createToolkit()
+  const sourceError = new Error('Plain 500 response')
   const request = {
+    method: 'post',
+    path: '/plain',
     response: {
       statusCode: statusCodes.internalServerError,
-      source: {
-        message: 'Plain 500 response'
-      }
+      source: sourceError
     }
   }
 
@@ -178,6 +211,48 @@ test('catchAll logs plain 500 responses before continuing', () => {
 
   // Assert
   assert.equal(result, toolkit.continue)
-  assert.deepEqual(logger.error.mock.calls[0], ['Plain 500 response'])
+  assert.deepEqual(logger.error.mock.calls[0], [
+    {
+      err: sourceError,
+      req: { method: 'post', url: '/plain' },
+      res: { statusCode: statusCodes.internalServerError }
+    },
+    'Request failed'
+  ])
   assert.equal(toolkit.view.mock.calls.length, 0)
 })
+
+test('catchAll falls back to a generated error when none is attached', () => {
+  // Arrange
+  const request = {
+    method: 'get',
+    path: '/x',
+    response: { statusCode: statusCodes.internalServerError, source: {} }
+  }
+
+  // Act
+  catchAll(request, createToolkit())
+
+  // Assert
+  expect(logger.error.mock.calls[0][0].err.message).toBe(
+    'Request failed with status 500'
+  )
+})
+
+test('catchAll logs the message of a plain 500 response whose source has one', () => {
+  // Arrange
+  const request = {
+    method: 'get',
+    path: '/x',
+    response: {
+      statusCode: statusCodes.internalServerError,
+      source: { message: 'Something broke' }
+    }
+  }
+
+  // Act
+  catchAll(request, createToolkit())
+
+  // Assert
+  expect(logger.error.mock.calls[0][0].err.message).toBe('Something broke')
+})

package/src/redis-client.js

@@ -65,7 +65,7 @@ export function buildRedisClient({
   })
 
   redisClient.on('error', (error) => {
-    logger?.error?.(`Redis connection error ${error}`)
+    logger?.error?.({ err: error }, 'Redis connection error')
   })
 
   return redisClient

package/src/redis-client.test.js

@@ -130,11 +130,13 @@ test('buildRedisClient uses the default port and logs client events', () => {
   })
 
   handlers.connect()
-  handlers.error(new Error('connection lost'))
+  const connectionError = new Error('connection lost')
+  handlers.error(connectionError)
 
   assert.deepEqual(logger.info.mock.calls[0], ['Connected to Redis server'])
   assert.deepEqual(logger.error.mock.calls[0], [
-    'Redis connection error Error: connection lost'
+    { err: connectionError },
+    'Redis connection error'
   ])
 })
 

package/src/status-codes.js

@@ -7,6 +7,7 @@ export const statusCodes = {
   notFound: 404,
   conflict: 409,
   imATeapot: 418,
+  unprocessableEntity: 422,
   internalServerError: 500,
   serviceUnavailable: 503
 }