commit 6ce8f052d3c827cc227c0a145cba6ef85a360bcd · nickmohoric.dev/plug_opentracing

+5

.gitignore

···

       1
       1
       +
       /_build

     

       2
       2
       +
       /deps

     

       3
       3
       +
       erl_crash.dump

     

       4
       4
       +
       *.ez

     

       5
       5
       +
       /doc

+5

.travis.yml

···

       1
       1
       +
       language: elixir

     

       2
       2
       +
       elixir:

     

       3
       3
       +
         - 1.5.1

     

       4
       4
       +
       otp_release:

     

       5
       5
       +
         - 20.0

+21

LICENSE.txt

···

       1
       1
       +
       MIT License

     

       2
       2
       +
       

     

       3
       3
       +
       Copyright (c) 2017 Nick Mohoric

     

       4
       4
       +
       

     

       5
       5
       +
       Permission is hereby granted, free of charge, to any person obtaining a copy

     

       6
       6
       +
       of this software and associated documentation files (the "Software"), to deal

     

       7
       7
       +
       in the Software without restriction, including without limitation the rights

     

       8
       8
       +
       to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

     

       9
       9
       +
       copies of the Software, and to permit persons to whom the Software is

     

       10
       10
       +
       furnished to do so, subject to the following conditions:

     

       11
       11
       +
       

     

       12
       12
       +
       The above copyright notice and this permission notice shall be included in all

     

       13
       13
       +
       copies or substantial portions of the Software.

     

       14
       14
       +
       

     

       15
       15
       +
       THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

     

       16
       16
       +
       IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

     

       17
       17
       +
       FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

     

       18
       18
       +
       AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

     

       19
       19
       +
       LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

     

       20
       20
       +
       OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

     

       21
       21
       +
       SOFTWARE.

+41

README.md

···

       1
       1
       +
       # PlugOpenTracing

     

       2
       2
       +
       

     

       3
       3
       +
       [![Build Status](https://travis-ci.org/nmohoric/plug_opentracing.svg?branch=master)](https://travis-ci.org/nmohoric/plug_opentracing)

     

       4
       4
       +
       

     

       5
       5
       +
       An Elixir Plug for adding OpenTracing instrumentation.

     

       6
       6
       +
       

     

       7
       7
       +
       ## Usage

     

       8
       8
       +
       

     

       9
       9
       +
       Update your `mix.exs` file and run `mix deps.get`.

     

       10
       10
       +
       ```elixir

     

       11
       11
       +
       defp deps do

     

       12
       12
       +
         [{:plug_opentracing, "~> 0.1"}]

     

       13
       13
       +
       end

     

       14
       14
       +
       ```

     

       15
       15
       +
       

     

       16
       16
       +
       Add the plug to a pipeline. In this case we will look for the

     

       17
       17
       +
       `uber-trace-id` header to exist. If so, it is split on `:` and

     

       18
       18
       +
       the first and second values are used as the trace_id and parent_id

     

       19
       19
       +
       when creating the span.

     

       20
       20
       +
       

     

       21
       21
       +
       ```elixir

     

       22
       22
       +
       defmodule MyPhoenixApp.MyController do

     

       23
       23
       +
         use MyPhoenixApp.Web, :controller

     

       24
       24
       +
         alias Plug.Conn.Status

     

       25
       25
       +
       

     

       26
       26
       +
         plug PlugOpenTracing, trace_id: 'uber-trace-id'

     

       27
       27
       +
         plug :action

     

       28
       28
       +
       

     

       29
       29
       +
         def index(conn, _params) do

     

       30
       30
       +
           conn

     

       31
       31
       +
           |> put_status(Status.code :ok)

     

       32
       32
       +
         end

     

       33
       33
       +
       end

     

       34
       34
       +
       

     

       35
       35
       +
       ```

     

       36
       36
       +
       The created span can be accessed using `conn.assigns[:trace_span]`. This is useful

     

       37
       37
       +
       when you want to use this span as the parent of another span in your request, or

     

       38
       38
       +
       if you want to add tags/logs to the span before it is finished.

     

       39
       39
       +
       

     

       40
       40
       +
       The request span will be finished at the end of your request using a callback,

     

       41
       41
       +
       which will send it to the Jaeger or Zipkin endpoint you've set up in your config.

+24

config/config.exs

···

       1
       1
       +
       # This file is responsible for configuring your application

     

       2
       2
       +
       # and its dependencies with the aid of the Mix.Config module.

     

       3
       3
       +
       use Mix.Config

     

       4
       4
       +
       

     

       5
       5
       +
       # This configuration is loaded before any dependency and is restricted

     

       6
       6
       +
       # to this project. If another project depends on this project, this

     

       7
       7
       +
       # file won't be loaded nor affect the parent project. For this reason,

     

       8
       8
       +
       # if you want to provide default values for your application for third-

     

       9
       9
       +
       # party users, it should be done in your mix.exs file.

     

       10
       10
       +
       

     

       11
       11
       +
       # Sample configuration:

     

       12
       12
       +
       #

     

       13
       13
       +
       #     config :logger, :console,

     

       14
       14
       +
       #       level: :info,

     

       15
       15
       +
       #       format: "$date $time [$level] $metadata$message\n",

     

       16
       16
       +
       #       metadata: [:user_id]

     

       17
       17
       +
       

     

       18
       18
       +
       # It is also possible to import configuration files, relative to this

     

       19
       19
       +
       # directory. For example, you can emulate configuration per environment

     

       20
       20
       +
       # by uncommenting the line below and defining dev.exs, test.exs and such.

     

       21
       21
       +
       # Configuration from the imported file will override the ones defined

     

       22
       22
       +
       # here (which is why it is important to import them last).

     

       23
       23
       +
       #

     

       24
       24
       +
       #     import_config "#{Mix.env}.exs"

+84

lib/plug_opentracing.ex

···

       1
       1
       +
       defmodule PlugOpenTracing do

     

       2
       2
       +
         @moduledoc """

     

       3
       3
       +
         A plug for adding OpenTracing instrumentation to requests.

     

       4
       4
       +
       

     

       5
       5
       +
         If a request already has a trace-id, the parts will be split

     

       6
       6
       +
         out and added as trace-id and parent-id in the new span. Otherwise,

     

       7
       7
       +
         a new span will be created.

     

       8
       8
       +
       

     

       9
       9
       +
         The default header is "uber-trace-id" but this can be set at compile time.

     

       10
       10
       +
       

     

       11
       11
       +
         At any point in the request you can access the span using conn.assigns[:trace].

     

       12
       12
       +
         This can then be used to either add tags onto it or use the span as a parent span

     

       13
       13
       +
         for other requests.

     

       14
       14
       +
       

     

       15
       15
       +
         To use it, just plug it into your module:

     

       16
       16
       +
       

     

       17
       17
       +
             plug PlugOpenTracing

     

       18
       18
       +
       

     

       19
       19
       +
         ## Options

     

       20
       20
       +
       

     

       21
       21
       +
           * `:trace_id` - An incoming trace-id. This should be hex and in the

     

       22
       22
       +
             form `trace-id:span-id` plus any optional bits that will be removed.

     

       23
       23
       +
       

     

       24
       24
       +
               plug PlugOpenTracing, trace_id: "my-trace-header"

     

       25
       25
       +
         """

     

       26
       26
       +
       

     

       27
       27
       +
         alias Plug.Conn

     

       28
       28
       +
         alias :otter, as: Otter

     

       29
       29
       +
         @behaviour Plug

     

       30
       30
       +
       

     

       31
       31
       +
         def init(opts) do

     

       32
       32
       +
           Keyword.get(opts, :trace_header, "uber-trace-id")

     

       33
       33
       +
         end

     

       34
       34
       +
       

     

       35
       35
       +
         def call(conn, trace_id_header) do

     

       36
       36
       +
           conn

     

       37
       37
       +
           |> get_trace_id(trace_id_header)

     

       38
       38
       +
           |> start_span()

     

       39
       39
       +
           |> tag_span()

     

       40
       40
       +
           |> register_span()

     

       41
       41
       +
         end

     

       42
       42
       +
       

     

       43
       43
       +
         defp get_trace_id(conn, header) do

     

       44
       44
       +
           case Conn.get_req_header(conn, header) do

     

       45
       45
       +
             []      -> {conn, nil}

     

       46
       46
       +
             [val|_] -> {conn, extract_id(String.split(val, ":"))}

     

       47
       47
       +
           end

     

       48
       48
       +
         end

     

       49
       49
       +
       

     

       50
       50
       +
         defp start_span({conn, [nil, _]}), do: start_span({conn, nil})

     

       51
       51
       +
         defp start_span({conn, [_, nil]}), do: start_span({conn, nil})

     

       52
       52
       +
         defp start_span({conn, [trace_id, span_id]}) do

     

       53
       53
       +
           {conn, Otter.start(conn.method, trace_id, span_id)}

     

       54
       54
       +
         end

     

       55
       55
       +
         defp start_span({conn, _}), do: {conn, Otter.start(conn.method)}

     

       56
       56
       +
       

     

       57
       57
       +
         defp tag_span({conn, span}) do

     

       58
       58
       +
           span = span

     

       59
       59
       +
                |> Otter.tag("path", Enum.join(Enum.map(conn.path_info, &URI.decode/1), "/"))

     

       60
       60
       +
                |> Otter.tag("method", conn.method)

     

       61
       61
       +
           conn |> Conn.assign(:trace_span, span)

     

       62
       62
       +
         end

     

       63
       63
       +
       

     

       64
       64
       +
         defp register_span(conn) do

     

       65
       65
       +
           Conn.register_before_send(conn, fn c ->

     

       66
       66
       +
             c.assigns[:trace_span]

     

       67
       67
       +
             |> Otter.finish()

     

       68
       68
       +
             c

     

       69
       69
       +
           end)

     

       70
       70
       +
         end

     

       71
       71
       +
       

     

       72
       72
       +
         defp extract_id(vals) when length(vals) >= 2 do

     

       73
       73
       +
             vals

     

       74
       74
       +
             |> Enum.take(2)

     

       75
       75
       +
             |> Enum.map(fn(s) -> s

     

       76
       76
       +
                               |> Integer.parse(16)

     

       77
       77
       +
                               |> case do

     

       78
       78
       +
                                 :error -> nil

     

       79
       79
       +
                                 i      -> elem(i,0)

     

       80
       80
       +
                               end

     

       81
       81
       +
                            end)

     

       82
       82
       +
         end

     

       83
       83
       +
         defp extract_id(_), do: nil

     

       84
       84
       +
       end

+43

mix.exs

···

       1
       1
       +
       defmodule PlugOpenTracing.Mixfile do

     

       2
       2
       +
         use Mix.Project

     

       3
       3
       +
       

     

       4
       4
       +
         def project do

     

       5
       5
       +
           [

     

       6
       6
       +
             app: :plug_opentracing,

     

       7
       7
       +
             version: "0.0.1",

     

       8
       8
       +
             name: "PlugOpenTracing",

     

       9
       9
       +
             source_url: "https://github.com/nmohoric/plug_opentracing",

     

       10
       10
       +
             elixir: "~> 1.0",

     

       11
       11
       +
             deps: deps(),

     

       12
       12
       +
             description: description(),

     

       13
       13
       +
             package: package()

     

       14
       14
       +
           ]

     

       15
       15
       +
         end

     

       16
       16
       +
       

     

       17
       17
       +
         defp description do

     

       18
       18
       +
           """

     

       19
       19
       +
           An Elixir Plug for adding opentracing instrumentation.

     

       20
       20
       +
           """

     

       21
       21
       +
         end

     

       22
       22
       +
       

     

       23
       23
       +
         defp package do

     

       24
       24
       +
           [

     

       25
       25
       +
             maintainers: ["Nick Mohoric"],

     

       26
       26
       +
             files: ["lib", "mix.exs", "README*", "LICENSE*"],

     

       27
       27
       +
             licenses: ["MIT"],

     

       28
       28
       +
             links: %{"GitHub" => "https://github.com/nmohoric/plug_opentracing"}

     

       29
       29
       +
           ]

     

       30
       30
       +
         end

     

       31
       31
       +
       

     

       32
       32
       +
         def application do

     

       33
       33
       +
           [applications: [:plug]]

     

       34
       34
       +
         end

     

       35
       35
       +
       

     

       36
       36
       +
         defp deps do

     

       37
       37
       +
           [

     

       38
       38
       +
             {:plug, "~> 1.3"},

     

       39
       39
       +
             {:ibrowse, "~> 4.4"},

     

       40
       40
       +
             {:otter, "~> 0.2.0"},

     

       41
       41
       +
           ]

     

       42
       42
       +
         end

     

       43
       43
       +
       end

+4

mix.lock

···

       1
       1
       +
       %{"ibrowse": {:hex, :ibrowse, "4.4.0", "2d923325efe0d2cb09b9c6a047b2835a5eda69d8a47ed6ff8bc03628b764e991", [], [], "hexpm"},

     

       2
       2
       +
         "mime": {:hex, :mime, "1.1.0", "01c1d6f4083d8aa5c7b8c246ade95139620ef8effb009edde934e0ec3b28090a", [], [], "hexpm"},

     

       3
       3
       +
         "otter": {:hex, :otter, "0.2.0", "0ca08e94db43c9ef6bf22a9b803a776880841e9f7fbf7b9207ade0cdeb0c6251", [], [], "hexpm"},

     

       4
       4
       +
         "plug": {:hex, :plug, "1.4.3", "236d77ce7bf3e3a2668dc0d32a9b6f1f9b1f05361019946aae49874904be4aed", [], [{:cowboy, "~> 1.0.1 or ~> 1.1", [hex: :cowboy, repo: "hexpm", optional: true]}, {:mime, "~> 1.0", [hex: :mime, repo: "hexpm", optional: false]}], "hexpm"}}

+53

test/plug_opentracing_test.exs

···

       1
       1
       +
       defmodule PlugOpenTracingTest do

     

       2
       2
       +
         use ExUnit.Case, async: true

     

       3
       3
       +
         use Plug.Test

     

       4
       4
       +
         alias Plug.Conn.Status

     

       5
       5
       +
       

     

       6
       6
       +
         test "missing trace header results in new span" do

     

       7
       7
       +
           connection = conn(:get, "/test-path")

     

       8
       8
       +
           response = TestApp.call(connection, [])

     

       9
       9
       +
       

     

       10
       10
       +
           assert response.status == Status.code(:ok)

     

       11
       11
       +
           assert response.resp_body != ""

     

       12
       12
       +
         end

     

       13
       13
       +
       

     

       14
       14
       +
         test "bad trace header results in new span" do

     

       15
       15
       +
           connection = conn(:get, "/test-path") |> put_req_header("uber-trace-id", "1234")

     

       16
       16
       +
           response = TestApp.call(connection, [])

     

       17
       17
       +
       

     

       18
       18
       +
           assert response.status == Status.code(:ok)

     

       19
       19
       +
           assert response.resp_body != ""

     

       20
       20
       +
         end

     

       21
       21
       +
       

     

       22
       22
       +
         test "valid trace header results in span with those ids" do

     

       23
       23
       +
           connection = conn(:get, "/test-path") |> put_req_header("uber-trace-id", "6a5c63925e01051b:150b1b1adcde6f4:6a5c63925e01051b:1")

     

       24
       24
       +
           response = TestApp.call(connection, [])

     

       25
       25
       +
       

     

       26
       26
       +
           assert response.status == Status.code(:ok)

     

       27
       27
       +
           assert response.resp_body == "7664110146171241755"

     

       28
       28
       +
         end

     

       29
       29
       +
       

     

       30
       30
       +
         test "invalid hex trace header results in usable span" do

     

       31
       31
       +
           connection = conn(:get, "/test-path") |> put_req_header("uber-trace-id", "6a5x63925t01051b:150b1p1adcdq6f4:6a5c63925e01051b:1")

     

       32
       32
       +
           response = TestApp.call(connection, [])

     

       33
       33
       +
       

     

       34
       34
       +
           assert response.status == Status.code(:ok)

     

       35
       35
       +
           assert response.resp_body == "1701"

     

       36
       36
       +
         end

     

       37
       37
       +
       

     

       38
       38
       +
         test "empty trace header results in new span" do

     

       39
       39
       +
           connection = conn(:get, "/test-path") |> put_req_header("uber-trace-id", "")

     

       40
       40
       +
           response = TestApp.call(connection, [])

     

       41
       41
       +
       

     

       42
       42
       +
           assert response.status == Status.code(:ok)

     

       43
       43
       +
           assert response.resp_body != ""

     

       44
       44
       +
         end

     

       45
       45
       +
       

     

       46
       46
       +
         test "just some colons results in new span" do

     

       47
       47
       +
           connection = conn(:get, "/test-path") |> put_req_header("uber-trace-id", "::::")

     

       48
       48
       +
           response = TestApp.call(connection, [])

     

       49
       49
       +
       

     

       50
       50
       +
           assert response.status == Status.code(:ok)

     

       51
       51
       +
           assert response.resp_body != ""

     

       52
       52
       +
         end

     

       53
       53
       +
       end

+28

test/test_helper.exs

···

       1
       1
       +
       ExUnit.start()

     

       2
       2
       +
       

     

       3
       3
       +
       defmodule AppMaker do

     

       4
       4
       +
         defmacro __using__(options) do

     

       5
       5
       +
           quote do

     

       6
       6
       +
             use Plug.Router

     

       7
       7
       +
             alias Plug.Conn.Status

     

       8
       8
       +
       

     

       9
       9
       +
             plug PlugOpenTracing, unquote(options)

     

       10
       10
       +
             plug :match

     

       11
       11
       +
             plug :dispatch

     

       12
       12
       +
           end

     

       13
       13
       +
         end

     

       14
       14
       +
       end

     

       15
       15
       +
       

     

       16
       16
       +
       defmodule TestApp do

     

       17
       17
       +
         alias :otter, as: Otter

     

       18
       18
       +
         use AppMaker, trace_header: "uber-trace-id"

     

       19
       19
       +
       

     

       20
       20
       +
         get "/test-path" do

     

       21
       21
       +
           send_resp(conn, Status.code(:ok), ids_to_string(conn))

     

       22
       22
       +
         end

     

       23
       23
       +
       

     

       24
       24
       +
         defp ids_to_string(conn) do

     

       25
       25
       +
           {trace_id, _} = Otter.ids(conn.assigns[:trace_span])

     

       26
       26
       +
           "#{Integer.to_string(trace_id)}"

     

       27
       27
       +
         end

     

       28
       28
       +
       end