Fail-Safe PII Redaction in Elixir

defmodule Parcel do
  @enforce_keys ~w(id name email phone)a
  defstruct [:id, :name, :email, :phone, :address, :items]
end

defmodule Secrets do
  @doc """
  Accepts a Parcel struct and returns a list of 
  values that are secrets that we don't want to see in our logs.
  """
  @spec from_parcel(Parcel.t()) :: [String.t()]
  def from_parcel(%Parcel{} = p) do
    [
      p.name,
      p.email,
      p.phone,
      p.address.street,
      p.address.city,
      p.address.postcode
    ]
    |> Enum.reject(&is_nil/1)
  end
end

defmodule SafeLog do
  require Logger

  @doc """
  Logs a payload at the given level, safely redacting any known secret values.

  If the payload is a map, it is encoded as JSON before logging.
  If the payload is a printable string, it is used directly.
  """
  @spec scrub_and_log(
          :debug | :info | :warn | :error,
          String.t(),
          map() | String.t(),
          [String.t()]
        ) :: :ok
  def scrub_and_log(level, message, payload, secrets)

  def scrub_and_log(level, message, payload, secrets) when is_map(payload) do
    payload
    |> Jason.encode!()
    |> redact_and_log(level, message, secrets)
  end

  def scrub_and_log(level, message, payload, secrets) when is_binary(payload) do
    if String.printable?(payload) do
      redact_and_log(level, message, payload, secrets)
    else
      Logger.warn("SafeLog attempted to log a non-printable binary, skipping.")
      :ok
    end
  end

  @spec redact_and_log(
          :debug | :info | :warn | :error,
          String.t(),
          String.t(),
          [String.t()]
        ) :: :ok
  defp redact_and_log(level, message, text, secrets) do
    redacted =
      secrets
      |> Enum.uniq()
      |> Enum.sort_by(&String.length/1, :desc)
      |> Enum.reduce(text, fn secret, acc ->
        String.replace(acc, secret, "[FILTERED]")
     end)

    Logger.log(level, fn -> "#{message} #{redacted}" end)
  end
end

defmodule ShippingExpressAdapter do
  @doc """
  Creates a shipping label by sending a request to the ShippingExpress API.

  Logs the request and response with PII safely scrubbed out,
  using the known secret values extracted from the Parcel struct.
  """
  @spec create_label(Parcel.t()) :: {:ok, map()} | {:error, any()}
  def create_label(%Parcel{} = parcel) do
    secrets = Secrets.from_parcel(parcel)
    request = build_request(parcel)

    SafeLog.scrub_and_log(:debug, "ShippingExpress request ⇢", request, secrets)

    with {:ok, raw_resp} <- HTTPClient.post(url(), request),
         {:ok, resp}     <- Jason.decode(raw_resp) do
      SafeLog.scrub_and_log(:debug, "ShippingExpress response ⇠", resp, secrets)
      parse_label(resp)
    end
  end
end