Conform attributes and span name to v1.27 semantics for OpentelemetryTesla (#469)

* Conform attributes and span name to v1.27 semantics for OpentelemetryTesla

* list out the aliases as fully qualified; use the semantic conventions for matches in tests

* Add comment for path_params in get_span_name/2 function

---------

Co-authored-by: Tristan Sloughter <[email protected]>

Author: ShapovalovaIrina

instrumentation/opentelemetry_tesla/lib/middleware/opentelemetry_tesla_middleware.ex

@@ -17,40 +17,54 @@ defmodule Tesla.Middleware.OpenTelemetry do
     Defaults to calling `:otel_propagator_text_map.get_text_map_injector/0`
     - `:mark_status_ok` - configures spans with a list of expected HTTP error codes to be marked as `ok`,
     not as an error-containing spans
+    - `:opt_in_attrs` - list of opt-in and experimental attributes to be added. Use semantic conventions library to ensure compatibility, e.g. `[HTTPAttributes.http_request_body_size()]`
+    - `:request_header_attrs` - list of request headers to be added as attributes, e.g. `["content-type"]`
+    - `:response_header_attrs` - list of response headers to be added as attributes, e.g. `["content-length"]`
   """
 
-  alias OpenTelemetry.SemanticConventions.Trace
+  alias OpenTelemetry.SemConv.ErrorAttributes
+  alias OpenTelemetry.SemConv.Incubating.HTTPAttributes
+  alias OpenTelemetry.SemConv.Incubating.URLAttributes
+  alias OpenTelemetry.SemConv.NetworkAttributes
+  alias OpenTelemetry.SemConv.ServerAttributes
+  alias OpenTelemetry.SemConv.UserAgentAttributes
 
   require OpenTelemetry.Tracer
-  require Trace
 
   @behaviour Tesla.Middleware
 
+  @otel_opts ~w[span_name propagator mark_status_ok opt_in_attrs request_header_attrs response_header_attrs]a
+
   def call(env, next, opts) do
-    span_name = get_span_name(env, Keyword.get(opts, :span_name))
+    opts = opts |> Keyword.take(@otel_opts) |> Enum.into(%{})
+    span_name = get_span_name(env, Map.get(opts, :span_name))
 
     OpenTelemetry.Tracer.with_span span_name, %{kind: :client} do
       env
       |> maybe_put_additional_ok_statuses(opts[:mark_status_ok])
-      |> maybe_propagate(Keyword.get(opts, :propagator, :opentelemetry.get_text_map_injector()))
+      |> maybe_propagate(Map.get(opts, :propagator, :opentelemetry.get_text_map_injector()))
+      |> set_req_span_attributes(opts)
       |> Tesla.run(next)
-      |> set_span_attributes()
+      |> set_resp_span_attributes(opts)
       |> handle_result()
     end
   end
 
-  defp get_span_name(_env, span_name) when is_binary(span_name) do
-    span_name
+  defp get_span_name(env, span_name) when is_binary(span_name) do
+    "#{http_method(env.method)} #{span_name}"
   end
 
   defp get_span_name(env, span_name_fun) when is_function(span_name_fun, 1) do
-    span_name_fun.(env)
+    "#{http_method(env.method)} #{span_name_fun.(env)}"
   end
 
   defp get_span_name(env, _) do
+    # `path_params` is used by `Tesla.Middleware.PathParams`
+    # if `path_params` is not set, the path potentially has high cardinality and we cannot use it in the span name
+    # if `path_params` is set, it means that the path is a template and we can use it in the span name
     case env.opts[:path_params] do
-      nil -> "HTTP #{http_method(env.method)}"
-      _ -> URI.parse(env.url).path
+      nil -> "#{http_method(env.method)}"
+      _ -> "#{http_method(env.method)} #{URI.parse(env.url).path}"
     end
   end
 
@@ -73,19 +87,14 @@ defmodule Tesla.Middleware.OpenTelemetry do
 
   defp maybe_put_additional_ok_statuses(env, _additional_ok_statuses), do: env
 
-  defp set_span_attributes({_, %Tesla.Env{} = env} = result) do
-    OpenTelemetry.Tracer.set_attributes(build_attrs(env))
-
-    result
-  end
-
-  defp set_span_attributes(result) do
-    result
-  end
-
   defp handle_result({:ok, %Tesla.Env{status: status, opts: opts} = env}) when status >= 400 do
     span_status =
-      if status in Keyword.get(opts, :additional_ok_statuses, []), do: :ok, else: :error
+      if status in Keyword.get(opts, :additional_ok_statuses, []) do
+        :ok
+      else
+        OpenTelemetry.Tracer.set_attribute(ErrorAttributes.error_type(), "#{status}")
+        :error
+      end
 
     span_status
     |> OpenTelemetry.status("")
@@ -95,7 +104,12 @@ defmodule Tesla.Middleware.OpenTelemetry do
   end
 
   defp handle_result({:error, {Tesla.Middleware.FollowRedirects, :too_many_redirects}} = result) do
-    OpenTelemetry.Tracer.set_status(OpenTelemetry.status(:error, ""))
+    OpenTelemetry.Tracer.set_attribute(
+      ErrorAttributes.error_type(),
+      Tesla.Middleware.FollowRedirects
+    )
+
+    OpenTelemetry.Tracer.set_status(OpenTelemetry.status(:error, "Too many redirects"))
 
     result
   end
@@ -104,41 +118,123 @@ defmodule Tesla.Middleware.OpenTelemetry do
     {:ok, env}
   end
 
-  defp handle_result(result) do
-    OpenTelemetry.Tracer.set_status(OpenTelemetry.status(:error, ""))
+  defp handle_result({:error, reason}) do
+    OpenTelemetry.Tracer.set_attribute(ErrorAttributes.error_type(), get_error_struct(reason))
+    OpenTelemetry.Tracer.set_status(OpenTelemetry.status(:error, format_error(reason)))
 
-    result
+    {:error, reason}
   end
 
-  defp build_attrs(%Tesla.Env{
-         method: method,
-         url: url,
-         status: status_code,
-         headers: headers,
-         query: query
-       }) do
-    url = Tesla.build_url(url, query)
+  defp set_req_span_attributes(%Tesla.Env{method: method, url: url, headers: headers} = env, opts) do
     uri = URI.parse(url)
 
-    attrs = %{
-      Trace.http_method() => http_method(method),
-      Trace.http_url() => url,
-      Trace.http_target() => uri.path,
-      Trace.net_host_name() => uri.host,
-      Trace.http_scheme() => uri.scheme,
-      Trace.http_status_code() => status_code
+    %{
+      HTTPAttributes.http_request_method() => http_method(method),
+      ServerAttributes.server_address() => uri.host,
+      ServerAttributes.server_port() => uri.port
+    }
+    |> add_opt_in_req_attrs(env, opts)
+    |> add_req_headers(headers, opts)
+    |> OpenTelemetry.Tracer.set_attributes()
+
+    env
+  end
+
+  defp set_resp_span_attributes(
+         {:ok, %Tesla.Env{url: url, query: query, status: status_code, headers: headers} = env},
+         opts
+       ) do
+    url = Tesla.build_url(url, query)
+
+    %{
+      # Sets url.full only after the request is completed so that all middleware has been called
+      URLAttributes.url_full() => url,
+      HTTPAttributes.http_response_status_code() => status_code
+    }
+    |> add_opt_in_resp_attrs(env, opts)
+    |> add_resp_headers(headers, opts)
+    |> OpenTelemetry.Tracer.set_attributes()
+
+    {:ok, env}
+  end
+
+  defp set_resp_span_attributes({:error, _} = result, _opts) do
+    result
+  end
+
+  defp add_opt_in_req_attrs(attrs, env, %{opt_in_attrs: [_ | _] = opt_in_attrs}) do
+    uri = URI.parse(env.url)
+
+    %{
+      HTTPAttributes.http_request_body_size() => get_header(env.headers, "content-length", "0"),
+      NetworkAttributes.network_transport() => :tcp,
+      URLAttributes.url_scheme() => uri.scheme,
+      URLAttributes.url_template() => get_url_template(env),
+      UserAgentAttributes.user_agent_original() => get_header(env.headers, "user-agent", "")
     }
+    |> Map.take(opt_in_attrs)
+    |> then(&Map.merge(attrs, &1))
+  end
+
+  defp add_opt_in_req_attrs(attrs, _uri, _opts), do: attrs
+
+  defp add_opt_in_resp_attrs(attrs, env, %{opt_in_attrs: [_ | _] = opt_in_attrs}) do
+    %{
+      HTTPAttributes.http_response_body_size() => get_header(env.headers, "content-length", "0")
+    }
+    |> Map.take(opt_in_attrs)
+    |> then(&Map.merge(attrs, &1))
+  end
 
-    maybe_append_content_length(attrs, headers)
+  defp add_opt_in_resp_attrs(attrs, _env, _opts), do: attrs
+
+  defp add_req_headers(
+         attrs,
+         req_headers,
+         %{request_header_attrs: [_ | _] = request_header_attrs}
+       ) do
+    Map.merge(
+      attrs,
+      :otel_http.extract_headers_attributes(
+        :request,
+        req_headers,
+        request_header_attrs
+      )
+    )
+  end
+
+  defp add_req_headers(attrs, _req_headers, _opts), do: attrs
+
+  defp add_resp_headers(
+         attrs,
+         resp_headers,
+         %{response_header_attrs: [_ | _] = response_header_attrs}
+       ) do
+    Map.merge(
+      attrs,
+      :otel_http.extract_headers_attributes(
+        :response,
+        resp_headers,
+        response_header_attrs
+      )
+    )
   end
 
-  defp maybe_append_content_length(attrs, headers) do
-    case Enum.find(headers, fn {k, _v} -> k == "content-length" end) do
-      nil ->
-        attrs
+  defp add_resp_headers(attrs, _resp_headers, _opts), do: attrs
 
-      {_key, content_length} ->
-        Map.put(attrs, Trace.http_response_content_length(), content_length)
+  defp get_url_template(env) do
+    case env.opts[:path_params] do
+      nil -> ""
+      _ -> URI.parse(env.url).path
+    end
+  end
+
+  defp get_header(headers, header_name, default) do
+    headers
+    |> Enum.find(fn {k, _v} -> k == header_name end)
+    |> case do
+      nil -> default
+      {_key, value} -> value
     end
   end
 
@@ -147,4 +243,10 @@ defmodule Tesla.Middleware.OpenTelemetry do
     |> Atom.to_string()
     |> String.upcase()
   end
+
+  defp format_error(%{__exception__: true} = exception), do: Exception.message(exception)
+  defp format_error(reason), do: inspect(reason)
+
+  defp get_error_struct(%{__struct__: struct}), do: struct
+  defp get_error_struct(_), do: ""
 end

instrumentation/opentelemetry_tesla/mix.exs

@@ -57,8 +57,9 @@ defmodule OpentelemetryTesla.MixProject do
       {:opentelemetry, "~> 1.0", only: :test},
       {:opentelemetry_api, "~> 1.2"},
       {:opentelemetry_telemetry, "~> 1.1"},
-      {:opentelemetry_semantic_conventions, "~> 0.2"},
+      {:opentelemetry_semantic_conventions, "~> 1.27"},
       {:tesla, "~> 1.4"},
+      {:otel_http, "~> 0.2"},
       {:ex_doc, "~> 0.38", only: :dev, runtime: false},
       {:bypass, "~> 2.1", only: :test},
       {:jason, "~> 1.3", only: :test}

instrumentation/opentelemetry_tesla/mix.lock

@@ -13,8 +13,9 @@
   "nimble_parsec": {:hex, :nimble_parsec, "1.4.2", "8efba0122db06df95bfaa78f791344a89352ba04baedd3849593bfce4d0dc1c6", [], [], "hexpm", "4b21398942dda052b403bbe1da991ccd03a053668d147d53fb8c4e0efe09c973"},
   "opentelemetry": {:hex, :opentelemetry, "1.5.0", "7dda6551edfc3050ea4b0b40c0d2570423d6372b97e9c60793263ef62c53c3c2", [:rebar3], [{:opentelemetry_api, "~> 1.4", [hex: :opentelemetry_api, repo: "hexpm", optional: false]}], "hexpm", "cdf4f51d17b592fc592b9a75f86a6f808c23044ba7cf7b9534debbcc5c23b0ee"},
   "opentelemetry_api": {:hex, :opentelemetry_api, "1.4.0", "63ca1742f92f00059298f478048dfb826f4b20d49534493d6919a0db39b6db04", [:mix, :rebar3], [], "hexpm", "3dfbbfaa2c2ed3121c5c483162836c4f9027def469c41578af5ef32589fcfc58"},
-  "opentelemetry_semantic_conventions": {:hex, :opentelemetry_semantic_conventions, "0.2.0", "b67fe459c2938fcab341cb0951c44860c62347c005ace1b50f8402576f241435", [:mix, :rebar3], [], "hexpm", "d61fa1f5639ee8668d74b527e6806e0503efc55a42db7b5f39939d84c07d6895"},
+  "opentelemetry_semantic_conventions": {:hex, :opentelemetry_semantic_conventions, "1.27.0", "acd0194a94a1e57d63da982ee9f4a9f88834ae0b31b0bd850815fe9be4bbb45f", [:mix, :rebar3], [], "hexpm", "9681ccaa24fd3d810b4461581717661fd85ff7019b082c2dff89c7d5b1fc2864"},
   "opentelemetry_telemetry": {:hex, :opentelemetry_telemetry, "1.1.2", "410ab4d76b0921f42dbccbe5a7c831b8125282850be649ee1f70050d3961118a", [:mix, :rebar3], [{:opentelemetry_api, "~> 1.3", [hex: :opentelemetry_api, repo: "hexpm", optional: false]}, {:telemetry, "~> 1.1", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "641ab469deb181957ac6d59bce6e1321d5fe2a56df444fc9c19afcad623ab253"},
+  "otel_http": {:hex, :otel_http, "0.2.0", "b17385986c7f1b862f5d577f72614ecaa29de40392b7618869999326b9a61d8a", [:rebar3], [], "hexpm", "f2beadf922c8cfeb0965488dd736c95cc6ea8b9efce89466b3904d317d7cc717"},
   "plug": {:hex, :plug, "1.15.3", "712976f504418f6dff0a3e554c40d705a9bcf89a7ccef92fc6a5ef8f16a30a97", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "cc4365a3c010a56af402e0809208873d113e9c38c401cabd88027ef4f5c01fd2"},
   "plug_cowboy": {:hex, :plug_cowboy, "2.7.0", "3ae9369c60641084363b08fe90267cbdd316df57e3557ea522114b30b63256ea", [:mix], [{:cowboy, "~> 2.7.0 or ~> 2.8.0 or ~> 2.9.0 or ~> 2.10.0", [hex: :cowboy, repo: "hexpm", optional: false]}, {:cowboy_telemetry, "~> 0.3", [hex: :cowboy_telemetry, repo: "hexpm", optional: false]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "d85444fb8aa1f2fc62eabe83bbe387d81510d773886774ebdcb429b3da3c1a4a"},
   "plug_crypto": {:hex, :plug_crypto, "2.0.0", "77515cc10af06645abbfb5e6ad7a3e9714f805ae118fa1a70205f80d2d70fe73", [:mix], [], "hexpm", "53695bae57cc4e54566d993eb01074e4d894b65a3766f1c43e2c61a1b0f45ea9"},