Custom Logging Policy

import { ZuploContext, ZuploRequest, ResponseSentEvent } from "@zuplo/runtime";
 
type CustomLoggingOptions = {
  endpoint: string;
};
 
const serializableHeaders = (headers: Headers) => {
  const output = {};
  headers.forEach((value, key) => {
    output[key] = value;
  });
  return output;
};
 
const serializableRequest = async (request: ZuploRequest) => {
  // if we're going to read the body, we need to clone
  // the request first - otherwise the response pipeline will
  // encounter a drained stream
  const clone = request.clone();
  const body = await clone.text(); // read as text
  const data = {
    method: request.method,
    url: request.url,
    headers: serializableHeaders(request.headers),
    body,
  };
 
  return data;
};
 
const serializableResponse = async (response: Response) => {
  // if we're going to read the body, we need to clone
  // the response first - otherwise the response pipeline will
  // encounter a drained stream
  const clone = response.clone();
  const body = await clone.text(); // read as text
 
  const data = {
    status: response.status,
    headers: serializableHeaders(response.headers),
    body,
  };
 
  return data;
};
 
const logReqRes = async (
  endpoint: string,
  req: any,
  response: Response,
  context: ZuploContext,
  start: number,
) => {
  // we don't want any errors thrown that might impact
  // our consumers experience so catch everything and
  // use context.log
  try {
    const data = {
      req,
      res: await serializableResponse(response),
      timeMs: Date.now() - start,
    };
 
    return fetch(endpoint, {
      method: "POST",
      body: JSON.stringify(data),
    });
  } catch (err) {
    context.log.error(err, "error in custom-logging policy");
  }
};
 
export default async function (
  request: ZuploRequest,
  context: ZuploContext,
  options: CustomLoggingOptions,
  policyName: string,
) {
  // We need to read the body of the request before it's used by the handler
  // so let's serialize the request now
  const req = await serializableRequest(request);
  const start = Date.now();
 
  // The 'responseSent' event will fire at the very last stage in the response
  // pipeline, when no more mutations can be made - so you can be confident
  // this was the response sent by Zuplo
  context.addEventListener("responseSent", async (event: ResponseSentEvent) => {
    const promise = logReqRes(
      options.endpoint,
      req,
      event.response,
      context,
      start,
    );
 
    // We need to ask the runtime now to shut down until this is complete,
    // as this will run asynchronously to our response
    context.waitUntil(promise);
  });
  return request;
}

{
  "name": "custom-logging-policy",
  "policyType": "custom-code-inbound",
  "handler": {
    "export": "default",
    "module": "$import(./modules/custom-logging)",
    "options": {
      "endpoint": "https://YOUR_MOCKIN_URL_HERE"
    }
  }
}