Ok, I’ve finally had the time to work on this.

I think I’ve managed to implement what you described @OvermindDL1. It seems to work, thanks!

I’ll share it here in case it’s helpful to anyone else. I would also appreciate suggestions on how to improve it.

My plugs:

# A pair of simple plugs

defmodule DynamicPlugs.Foo do
  require Logger

  def init(opts) do
    Logger.debug "Foo.init(opts)        -> #{inspect opts}"
    Keyword.get(opts, :foo)
  end

  def call(conn, opts) do
    Logger.debug "Foo.call(conn, opts)  -> #{inspect opts}"
    conn
  end
end

defmodule DynamicPlugs.Bar do
  require Logger

  def init(opts) do
    Logger.debug "Bar.init(opts)        -> #{inspect opts}"
    Keyword.get(opts, :bar)
  end

  def call(conn, opts) do
    Logger.debug "Bar.call(conn, opts)  -> #{inspect opts}"
    conn
  end
end

# --------------------------------------------------------
# Main "public" plug

defmodule DynamicPlugs.Main do
  require Logger

  defmacrop do_build_dynamic_proxy(args) do
    quote do
      defmodule Proxy do
        use Plug.Builder

        plug DynamicPlugs.Foo, unquote(args)
        plug DynamicPlugs.Bar, unquote(args)
      end
    end
  end

  defp build_proxy(args) do
    {:module, proxy, _, _} = do_build_dynamic_proxy(args)
    proxy
  end

  def init(opts) do
    Logger.debug "Main.init(opts)       -> #{inspect opts}"
    [proxy: build_proxy(opts)]
  end

  def call(conn, opts) do
    Logger.debug "Main.call(conn, opts) -> #{inspect opts}"
    opts[:proxy].call(conn, [])
  end
end

With this setup, I can plug the main module in a Plug router:

plug DynamicPlugs.Main, foo: %{a: 1}, bar: %{b: 2}, baz: "ignored"

And then on the Plug server I get:

Compiling 19 files (.ex)

01:33:06.071 [debug] Main.init(opts)       -> [foo: %{a: 1}, bar: %{b: 2}, baz: "ignored"]

01:33:06.101 [debug] Bar.init(opts)        -> [foo: %{a: 1}, bar: %{b: 2}, baz: "ignored"]

01:33:06.102 [debug] Foo.init(opts)        -> [foo: %{a: 1}, bar: %{b: 2}, baz: "ignored"]
Generated XXXXX app

01:33:08.168 [debug] GET /

01:33:08.194 [debug] Main.call(conn, opts) -> [proxy: DynamicPlugs.Main.Proxy]

01:33:08.194 [debug] Foo.call(conn, opts)  -> %{a: 1}

01:33:08.194 [debug] Bar.call(conn, opts)  -> %{b: 2}

01:33:08.195 [debug] Sent 204 in 26ms

Thanks a lot for sharing your implementation! I was running into a similar problem while writing a small wrapper for a public plug and I was able to fix it with due to this topic and your solution!

I realize it’s been 7 years since this topic opened, but there is one important detail to add that can save future readers some problems and headaches: init/1 (and therefore the module-generating macro inside it) is evaluated at compile-time, meaning that in order to be able to use your wrapping plug in multiple places in your code, you must also incorporate a unique ID in your generated module’s name, otherwise you’ll just end up redefining the same module, overwriting its previous implementations, meaning only the latest compiled module will remain. That likely causes the wrong set of options to be used in most places where you’re using this plug. For me, it also caused some flakiness in my tests due to compilation race conditions.

Here’s what my solution incorporating such a unique ID looks like:

defmodule WrapperPlug do
  @behaviour Plug

  defmacrop build(opts, id) do
    # note: do not define `id` here, this line will only be executed once during compilation.
    # id = ...

    quote location: :keep do
      defmodule "Impl#{unquote(id)}" |> String.to_atom() do
        use Plug.Builder

        plug ChildPlug, unquote(opts)

        # ...
      end
    end
  end

  @impl Plug
  def init(opts) do
    # init is evaluated at compile-time, so a unique integer ID is used to ensure
    # that multiple instances of this plug can co-exist in one codebase.
    id = :erlang.unique_integer([:positive])
    {:module, mod, _, _} = build(opts, id)
    [mod: mod]
  end

  @impl Plug
  def call(conn, opts) do
    opts[:mod].call(conn, opts)
  end
end

Yes, I get that, but so is the output of MainPlug.init/1, and I was hoping that there was some macro to store it in a module attribute and pass it down to the other plugs.
Looking into the code of Plug.Builder, however, I can see that the plug pipeline is “resolved and frozen” in __before_compile__, and I guess that the MainPlug module (or any module plug, really) is compiled before it gets referenced in the forward "/" ... call.

I can, but my child plugs are executed before MainPlug.call/2 is called, so it doesn’t really help me unless I manually invoke the plugs instead of relying on the plug macro.

Basically plug MyModule generates essentially (not really, but this gets the point across more simply) def do_plug(state), do: MyModule.call(state, unquote(MyModule.init([])). What you could do is generate a new location-sensitive module name dynamically generated, generate a proxy module that sets up the pipeline then pass the name of it back in the options, then call it inside your call to do the actual work.

Hard to give a good example currently, maybe if I get time later to actually write it out, poke me if so?

I can’t edit my original response anymore, but I’ve found out that :erlang.unique_integer([:positive]) may return the same integer twice between two separate runs of the Erlang VM, which could already happen with a console command as simple as mix compile && mix test.

It’s better to use a :crypto.hash of the module name plus options object:

    id =
      :sha256
      |> :crypto.hash(Macro.to_string(__MODULE__) <> Macro.to_string(opts))
      |> binary_part(0, 4)
      |> :crypto.bytes_to_integer()