Add User-Agent header when requesting registry (#100)

Closes #101

Author: azeemchauhan

README.md

@@ -22,6 +22,7 @@
 [v0.22]: https://github.com/Strech/avrora/releases/tag/v0.22.0
 [v0.23]: https://github.com/Strech/avrora/releases/tag/v0.23.0
 [v0.24]: https://github.com/Strech/avrora/releases/tag/v0.24.0
+[v0.25]: https://github.com/Strech/avrora/releases/tag/v0.25.0
 [1]: https://avro.apache.org/
 [2]: https://www.confluent.io/confluent-schema-registry
 [3]: https://docs.confluent.io/current/schema-registry/serializer-formatter.html#wire-format
@@ -84,6 +85,7 @@ defmodule MyClient do
     otp_app: :my_application,
     registry_url: "http://localhost:8081",
     registry_auth: {:basic, ["username", "password"]},
+    registry_user_agent: "Avrora/0.25.0 Elixir",
     schemas_path: "./priv/schemas",
     registry_schemas_autoreg: false,
     convert_null_values: false,
@@ -104,6 +106,7 @@ config :avrora,
   otp_app: :my_application, # optional, if you want to use it as a root folder for `schemas_path`
   registry_url: "http://localhost:8081",
   registry_auth: {:basic, ["username", "password"]}, # optional
+  registry_user_agent: "Avrora/0.24.2 Elixir", # optional: if you want to return previous behaviour, set it to `nil`
   schemas_path: "./priv/schemas",
   registry_schemas_autoreg: false, # optional: if you want manually register schemas
   convert_null_values: false, # optional: if you want to keep decoded `:null` values as is
@@ -115,6 +118,7 @@ config :avrora,
 - `otp_app`<sup>[v0.22]</sup> - Name of the OTP application to use for runtime configuration via env, default `nil`
 - `registry_url` - URL for the Schema Registry, default `nil`
 - `registry_auth` – Credentials to authenticate in the Schema Registry, default `nil`
+- `registry_user_agent`<sup>[v0.25]</sup> - HTTP `User-Agent` header for Schema Registry requests, default `Avrora/<version> Elixir`
 - `schemas_path` - Base path for locally stored schema files, default `./priv/schemas`
 - `registry_schemas_autoreg`<sup>[v0.13]</sup> - Flag for automatic schemas registration in the Schema Registry, default `true`
 - `convert_null_values`<sup>[v0.14]</sup> - Flag for automatic conversion of decoded `:null` values into `nil`, default `true`

config/config.exs

@@ -4,6 +4,7 @@ config :avrora,
   schemas_path: Path.expand("./test/fixtures/schemas"),
   registry_url: nil,
   registry_auth: nil,
+  registry_user_agent: nil,
   registry_schemas_autoreg: true,
   convert_null_values: true,
   names_cache_ttl: :infinity

lib/avrora/client.ex

@@ -111,6 +111,7 @@ defmodule Avrora.Client do
 
           def registry_url, do: get(@opts, :registry_url, nil)
           def registry_auth, do: get(@opts, :registry_auth, nil)
+          def registry_user_agent, do: get(@opts, :registry_user_agent, "Avrora/#{version()} Elixir")
           def registry_schemas_autoreg, do: get(@opts, :registry_schemas_autoreg, true)
           def convert_null_values, do: get(@opts, :convert_null_values, true)
           def convert_map_to_proplist, do: get(@opts, :convert_map_to_proplist, false)
@@ -122,6 +123,8 @@ defmodule Avrora.Client do
           def http_client, do: Avrora.HTTPClient
           def ets_lib, do: :"Elixir.#{unquote(module)}.AvroSchemaStore"
 
+          defp version, do: Application.spec(:avrora, :vsn)
+
           if is_nil(@otp_app) do
             def self, do: __MODULE__
 

lib/avrora/config.ex

@@ -8,6 +8,7 @@ defmodule Avrora.Config do
       * `schemas_path` path to local schema files, default `./priv/schemas`
       * `registry_url` URL for Schema Registry, default `nil`
       * `registry_auth` authentication settings for Schema Registry, default `nil`
+      * `registry_user_agent` HTTP `User-Agent` header for Schema Registry requests, default `Avrora/<version> Elixir`
       * `registry_schemas_autoreg` automatically register schemas in Schema Registry, default `true`
       * `convert_null_values` convert `:null` values in the decoded message into `nil`, default `true`
       * `convert_map_to_proplist` bring back old behavior and configure decoding AVRO map-type as proplist, default `false`
@@ -26,6 +27,7 @@ defmodule Avrora.Config do
   @callback schemas_path :: String.t()
   @callback registry_url :: String.t() | nil
   @callback registry_auth :: tuple() | nil
+  @callback registry_user_agent :: String.t() | nil
   @callback registry_schemas_autoreg :: boolean()
   @callback convert_null_values :: boolean()
   @callback convert_map_to_proplist :: boolean()
@@ -51,6 +53,9 @@ defmodule Avrora.Config do
   @doc false
   def registry_auth, do: get_env(:registry_auth, nil)
 
+  @doc false
+  def registry_user_agent, do: get_env(:registry_user_agent, "Avrora/#{version()} Elixir")
+
   @doc false
   def registry_schemas_autoreg, do: get_env(:registry_schemas_autoreg, true)
 
@@ -85,4 +90,5 @@ defmodule Avrora.Config do
   def self, do: get_env(:config, Avrora.Config)
 
   defp get_env(name, default), do: Application.get_env(:avrora, name, default)
+  defp version, do: Application.spec(:avrora, :vsn)
 end

lib/avrora/http_client.ex

@@ -28,9 +28,15 @@ defmodule Avrora.HTTPClient do
   end
 
   defp extract_headers(options) do
-    case Keyword.get(options, :authorization) do
-      nil -> {:ok, []}
-      credentials -> {:ok, [{'Authorization', '#{credentials}'}]}
+    authorization =
+      case Keyword.get(options, :authorization) do
+        nil -> []
+        credentials -> [{'Authorization', '#{credentials}'}]
+      end
+
+    case Keyword.get(options, :user_agent) do
+      nil -> {:ok, authorization}
+      user_agent -> {:ok, [{'User-Agent', '#{user_agent}'} | authorization]}
     end
   end
 

lib/avrora/storage/registry.ex

@@ -131,13 +131,19 @@ defmodule Avrora.Storage.Registry do
 
   # NOTE: Maybe move to compile-time?
   defp headers do
-    case registry_auth() do
-      {:basic, [username, password]} ->
-        credentials = :base64.encode("#{username}:#{password}")
-        [authorization: "Basic #{credentials}"]
+    authorization =
+      case registry_auth() do
+        {:basic, [username, password]} ->
+          credentials = :base64.encode("#{username}:#{password}")
+          [authorization: "Basic #{credentials}"]
+
+        nil ->
+          []
+      end
 
-      nil ->
-        []
+    case registry_user_agent() do
+      nil -> authorization
+      user_agent -> authorization |> Keyword.put(:user_agent, user_agent)
     end
   end
 
@@ -162,4 +168,5 @@ defmodule Avrora.Storage.Registry do
   defp http_client, do: Config.self().http_client()
   defp registry_url, do: Config.self().registry_url()
   defp registry_auth, do: Config.self().registry_auth()
+  defp registry_user_agent, do: Config.self().registry_user_agent()
 end

test/avrora/storage/registry_test.exs

@@ -292,6 +292,29 @@ defmodule Avrora.Storage.RegistryTest do
       assert schema.full_name == "io.confluent.Payment"
     end
 
+    test "when request with user agent was successful" do
+      stub(Avrora.ConfigMock, :registry_user_agent, fn -> "Avrora/0.0.1 Elixir" end)
+
+      Avrora.HTTPClientMock
+      |> expect(:post, fn url, payload, options ->
+        assert url == "http://reg.loc/subjects/io.confluent.Payment/versions"
+        assert payload == json_schema()
+
+        assert options == [
+                 content_type: "application/vnd.schemaregistry.v1+json",
+                 user_agent: "Avrora/0.0.1 Elixir"
+               ]
+
+        {:ok, %{"id" => 1}}
+      end)
+
+      {:ok, schema} = Registry.put("io.confluent.Payment", json_schema())
+
+      assert schema.id == 1
+      assert is_nil(schema.version)
+      assert schema.full_name == "io.confluent.Payment"
+    end
+
     test "when key contains version and request was successful" do
       Avrora.HTTPClientMock
       |> expect(:post, fn url, payload, _ ->

test/support/config.ex

@@ -40,6 +40,8 @@ defmodule Support.Config do
   @impl true
   def registry_auth, do: nil
   @impl true
+  def registry_user_agent, do: nil
+  @impl true
   def registry_schemas_autoreg, do: true
   @impl true
   def convert_null_values, do: true