unleash_fresha

defmodule Unleash.Propagation.GRPC.ContextClientInterceptor do
  @moduledoc """
  A gRPC Client Interceptor designed to propagate Unleash context and overrides downstream.

  The context and overrides must be established in the propagation context,
  either manually (using `Unleash.Propagation.put_context/1`)
  or through middleware, such as
  `Unleash.Propagation.GRPC.ContextClientInterceptor` or
  `Unleash.Propagation.Plugs.extract_unleash_context/2`.

  For further details on the propagation mechanism, see `Unleash.Propagation`.

  Note that this interceptor will raise if it finds invalid context or overrides values
  in the propagation context that it can't serialize. This can happen if you put values
  in the propagation context manually and you do so incorrectly.

  If you'd like to prevent such instances from breaking your gRPC requests,
  you can easily build your own interceptor that wraps this one and catches errors, for example:

      defmodule MyUnleashContextClientInterceptorWrapper do
        @moduledoc false
        @behaviour GRPC.ClientInterceptor

        @impl true
        def init(_), do: nil

        def call(stream, req, next, opts) do
          Unleash.Propagation.GRPC.ContextClientInterceptor.call(stream, req, next, opts)
        rescue
          err ->
            Logger.error("your error message here")
            next.(stream, req)  # Continue the gRPC request processing
        end
      end
  """

  @behaviour GRPC.ClientInterceptor

  import Unleash.Propagation.Serialization, only: [serialize_context!: 1, serialize_overrides!: 1]

  alias Unleash.Propagation

  @impl true
  def init(_), do: nil

  @impl true
  def call(stream, req, next, _opts) do
    context = Propagation.get_context()
    overrides = Propagation.get_overrides()

    headers =
      Map.filter(
        %{
          "x-unleash-context" => if(is_nil(context), do: nil, else: serialize_context!(context)),
          "x-unleash-overrides" =>
            if(is_nil(overrides), do: nil, else: serialize_overrides!(overrides))
        },
        fn {_key, val} -> not is_nil(val) end
      )

    stream = Map.update(stream, :headers, headers, &Map.merge(&1, headers))
    next.(stream, req)
  end
end