From 96de935df8cf73526240ce421b2acc97284a92b1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Szczygie=C5=82?=
 <1153719+mszczygiel@users.noreply.github.com>
Date: Sun, 13 Oct 2019 21:39:52 +0200
Subject: [PATCH 1/8] bump opencensus

---
 mix.lock | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mix.lock b/mix.lock
index 0b1ef6f..d4124d4 100644
--- a/mix.lock
+++ b/mix.lock
@@ -21,7 +21,7 @@
   "mimerl": {:hex, :mimerl, "1.0.2", "993f9b0e084083405ed8252b99460c4f0563e41729ab42d9074fd5e52439be88", [:rebar3], [], "hexpm"},
   "mix_test_watch": {:hex, :mix_test_watch, "0.9.0", "c72132a6071261893518fa08e121e911c9358713f62794a90c95db59042af375", [:mix], [{:file_system, "~> 0.2.1 or ~> 0.3", [hex: :file_system, repo: "hexpm", optional: false]}], "hexpm"},
   "nimble_parsec": {:hex, :nimble_parsec, "0.4.0", "ee261bb53214943679422be70f1658fff573c5d0b0a1ecd0f18738944f818efe", [:mix], [], "hexpm"},
-  "opencensus": {:hex, :opencensus, "0.9.1", "47481a832f46883d9b5cdec51d3c693e40e7324a5e3b4dfd9012a27152aa6df6", [:rebar3], [{:counters, "~> 0.2.1", [hex: :counters, repo: "hexpm", optional: false]}, {:ctx, "~> 0.5", [hex: :ctx, repo: "hexpm", optional: false]}, {:wts, "~> 0.3", [hex: :wts, repo: "hexpm", optional: false]}], "hexpm"},
+  "opencensus": {:hex, :opencensus, "0.9.2", "ab36b0c4e4500b976180bd088cea7520d345711a72df2d7188e2d7b9573a8728", [:rebar3], [{:counters, "~> 0.2.1", [hex: :counters, repo: "hexpm", optional: false]}, {:ctx, "~> 0.5", [hex: :ctx, repo: "hexpm", optional: false]}, {:wts, "~> 0.3", [hex: :wts, repo: "hexpm", optional: false]}], "hexpm"},
   "parse_trans": {:hex, :parse_trans, "3.3.0", "09765507a3c7590a784615cfd421d101aec25098d50b89d7aa1d66646bc571c1", [:rebar3], [], "hexpm"},
   "poison": {:hex, :poison, "3.1.0", "d9eb636610e096f86f25d9a46f35a9facac35609a7591b3be3326e99a0484665", [:mix], [], "hexpm"},
   "rfc3339": {:hex, :rfc3339, "0.9.0", "2075653dc9407541c84b1e15f8bda2abe95fb17c9694025e079583f2d19c1060", [:mix, :rebar], [], "hexpm"},

From 90edf2f8f1c123c1870b40088d03f497351c7d77 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Szczygie=C5=82?=
 <1153719+mszczygiel@users.noreply.github.com>
Date: Tue, 15 Oct 2019 21:32:08 +0200
Subject: [PATCH 2/8] exporting opencensus metrics

---
 config/config.exs                             |  12 +-
 lib/opencensus/metrics.ex                     |  88 ++++++++++
 .../test_support/metrics_capture_exporter.ex  |  39 +++++
 test/opencensus_metrics_test.exs              | 165 ++++++++++++++++++
 test/test_helper.exs                          |   1 +
 5 files changed, 303 insertions(+), 2 deletions(-)
 create mode 100644 lib/opencensus/metrics.ex
 create mode 100644 lib/opencensus/test_support/metrics_capture_exporter.ex
 create mode 100644 test/opencensus_metrics_test.exs

diff --git a/config/config.exs b/config/config.exs
index 369af7c..53583d6 100644
--- a/config/config.exs
+++ b/config/config.exs
@@ -8,6 +8,14 @@ if Mix.env() == :test do
     report_dir: "reports/exunit"
 
   config :opencensus,
-    reporters: [{Opencensus.TestSupport.SpanCaptureReporter, []}],
-    send_interval_ms: 100
+    reporters: [
+      {Opencensus.TestSupport.SpanCaptureReporter, []}
+    ],
+    send_interval_ms: 100,
+    stat: [
+      export_interval: 100,
+      exporters: [
+        {Opencensus.TestSupport.MetricsCaptureExporter, []}
+      ]
+    ]
 end
diff --git a/lib/opencensus/metrics.ex b/lib/opencensus/metrics.ex
new file mode 100644
index 0000000..4420636
--- /dev/null
+++ b/lib/opencensus/metrics.ex
@@ -0,0 +1,88 @@
+defmodule Opencensus.Metrics do
+  @moduledoc """
+  Functions to help Elixir programmers use OpenCensus metrics.
+
+  First, a measure must be created:
+  ```elixir
+  Metrics.new_measure(:name, "description", :unit)
+  Metrics.new_measure(:another, "", :unit)
+  ```
+
+  Next step is to choose aggregations to be exported:
+  ```elixir
+  Metrics.aggregate_count(:name_count, :name, "count", [:tag1, :tag2])
+  Metrics.aggregate_gauge(:name_gauge, :name, "gauge", [:tag1, :tag2])
+  Metrics.aggregate_sum(:name_sum, :name, "sum", [:tag1, :tag2])
+  Metrics.aggregate_distribution(:name_distribution, :name, "distribution", [:tag1, :tag2], [0, 100, 1000])
+  ```
+
+  After aggregations are decided, measures may be recorded by explicitly providing tags:
+  ```elixir
+  Metrics.record(:name, %{tag1: "v1", tag2: "v2"}, 3)
+  Metrics.record([another: 1, name: 100], %{tag1: "v1", tag2: "v2})
+  ```
+  or using tag values that are present in process dictionary:
+  ```elixir
+  Metrics.record(:name, 3)
+  ```
+  """
+
+  def new_measure(name, description, unit) do
+    :oc_stat_measure.new(name, description, unit)
+  end
+
+  @doc """
+  count of how many times `measure` was recorded will be exported
+  """
+  def aggregate_count(name, measure, description, tags) do
+    :oc_stat_view.subscribe(name, measure, description, tags, :oc_stat_aggregation_count)
+  end
+
+  @doc """
+  only latest recorded value of `measure` will be exported
+  """
+  def aggregate_gauge(name, measure, description, tags) do
+    :oc_stat_view.subscribe(name, measure, description, tags, :oc_stat_aggregation_latest)
+  end
+
+  @doc """
+  sum of all recorded values of `measure` will be exported
+  """
+  def aggregate_sum(name, measure, description, tags) do
+    :oc_stat_view.subscribe(name, measure, description, tags, :oc_stat_aggregation_sum)
+  end
+
+  @doc """
+  distribution of all recorded values of `measure` across all `buckets` will be exported
+  """
+  def aggregate_distribution(name, measure, description, tags, buckets) do
+    :oc_stat_view.subscribe(
+      name,
+      measure,
+      description,
+      tags,
+      {:oc_stat_aggregation_distribution, buckets: buckets}
+    )
+  end
+
+  @doc """
+  records single measure
+  """
+  def record(measure, %{} = tags, value) when is_number(value) do
+    :oc_stat.record(tags, measure, value)
+  end
+
+  @doc """
+  records multiple measures
+  """
+  def record(measures, %{} = tags) when is_list(measures) do
+    :oc_stat.record(tags, measures)
+  end
+
+  @doc """
+  records single measure, takes tags from process dictionary
+  """
+  def record(measure, value) when is_atom(measure) and is_number(value) do
+    :ocp.record(measure, value)
+  end
+end
diff --git a/lib/opencensus/test_support/metrics_capture_exporter.ex b/lib/opencensus/test_support/metrics_capture_exporter.ex
new file mode 100644
index 0000000..fbc57be
--- /dev/null
+++ b/lib/opencensus/test_support/metrics_capture_exporter.ex
@@ -0,0 +1,39 @@
+defmodule Opencensus.TestSupport.MetricsCaptureExporter do
+  @moduledoc """
+    An `:oc_stat_exporter` to capture exported metrics. To wait for next exported data to be returned, call `capture_next`.
+  """
+  use GenServer
+  @behaviour :oc_stat_exporter
+
+  def start_link do
+    GenServer.start_link(__MODULE__, nil, name: __MODULE__)
+  end
+
+  def capture_next do
+    GenServer.call(__MODULE__, :capture_next)
+  end
+
+  @impl GenServer
+  def init(_arg) do
+    {:ok, [send_to: nil]}
+  end
+
+  @impl :oc_stat_exporter
+  def export(view, _config) do
+    GenServer.cast(__MODULE__, {:export, view})
+  end
+
+  @impl GenServer
+  def handle_call(:capture_next, from, send_to: nil) do
+    {:noreply, send_to: from}
+  end
+
+  @impl GenServer
+  def handle_cast({:export, view}, send_to: pid) do
+    unless pid == nil do
+      GenServer.reply(pid, view)
+    end
+
+    {:noreply, send_to: nil}
+  end
+end
diff --git a/test/opencensus_metrics_test.exs b/test/opencensus_metrics_test.exs
new file mode 100644
index 0000000..8c5445d
--- /dev/null
+++ b/test/opencensus_metrics_test.exs
@@ -0,0 +1,165 @@
+defmodule Opencensus.MetricsTest do
+  alias Opencensus.Metrics
+  alias Opencensus.TestSupport.MetricsCaptureExporter, as: Capture
+
+  use ExUnit.Case, async: false
+
+  describe "Aggregate measurements" do
+    test "counter" do
+      measure_name = :measure1
+      tag_names = [:t1, :t2]
+      Metrics.new_measure(measure_name, "A test measure", :milli_second)
+
+      Metrics.aggregate_count(
+        :test_count,
+        measure_name,
+        "A counter",
+        tag_names
+      )
+
+      record_measures(measure_name)
+
+      %{
+        data: %{rows: rows, type: :count},
+        description: "A counter",
+        tags: tags,
+        name: :test_count
+      } = capture_aggregate(:test_count)
+
+      expected_rows = [
+        %{tags: ["A", "a"], value: 2},
+        %{tags: ["B", "b"], value: 3}
+      ]
+
+      assert tags == [:t2, :t1]
+      assert Enum.sort(expected_rows) == Enum.sort(rows)
+    end
+
+    test "gauge" do
+      measure_name = :measure2
+      Metrics.new_measure(measure_name, "A test measure", :milli_seconds)
+
+      Metrics.aggregate_gauge(:test_gauge, measure_name, "A gauge", [:t1, :t2])
+
+      record_measures(measure_name)
+
+      %{
+        data: %{rows: rows, type: :latest},
+        description: "A gauge",
+        tags: tags,
+        name: :test_gauge
+      } = capture_aggregate(:test_gauge)
+
+      expected_rows = [
+        %{tags: ["A", "a"], value: 20},
+        %{tags: ["B", "b"], value: 51}
+      ]
+
+      assert tags == [:t2, :t1]
+      assert Enum.sort(expected_rows) == rows
+    end
+
+    test "sum" do
+      measure_name = :measure3
+      Metrics.new_measure(measure_name, "A test measure", :milli_seconds)
+      Metrics.aggregate_sum(:test_sum, measure_name, "A sum", [:t1, :t2])
+
+      record_measures(measure_name)
+
+      %{
+        data: %{rows: rows, type: :sum},
+        description: "A sum",
+        tags: tags,
+        name: :test_sum
+      } = capture_aggregate(:test_sum)
+
+      expected_rows = [
+        %{tags: ["A", "a"], value: %{count: 2, sum: 30, mean: 15.0}},
+        %{tags: ["B", "b"], value: %{count: 3, sum: 114, mean: 38.0}}
+      ]
+
+      assert tags == [:t2, :t1]
+      assert Enum.sort(expected_rows) == rows
+    end
+
+    test "distribution" do
+      measure_name = :measure4
+      Metrics.new_measure(measure_name, "A test measure", :milli_seconds)
+
+      Metrics.aggregate_distribution(
+        :test_distribution,
+        measure_name,
+        "A distribution",
+        [:t1, :t2],
+        [0, 10, 20, 30, 40, 50]
+      )
+
+      record_measures(measure_name)
+
+      %{
+        data: %{rows: rows, type: :distribution},
+        description: "A distribution",
+        tags: tags,
+        name: :test_distribution
+      } = capture_aggregate(:test_distribution)
+
+      expected_rows = [
+        %{
+          tags: ["A", "a"],
+          value: %{
+            count: 2,
+            sum: 30,
+            mean: 15.0,
+            buckets: [{0, 0}, {10, 1}, {20, 1}, {30, 0}, {40, 0}, {50, 0}, {:infinity, 0}]
+          }
+        },
+        %{
+          tags: ["B", "b"],
+          value: %{
+            count: 3,
+            sum: 114,
+            mean: 38.0,
+            buckets: [{0, 0}, {10, 0}, {20, 0}, {30, 0}, {40, 2}, {50, 0}, {:infinity, 1}]
+          }
+        }
+      ]
+
+      assert tags == [:t2, :t1]
+      assert Enum.sort(expected_rows) == rows
+    end
+  end
+
+  describe "using tags from process dictionary" do
+    test "tag values are taken from process dictionary" do
+      :ocp.with_tags(%{tag: "value"})
+      Metrics.new_measure(:measure10, "measure", :bytes)
+
+      Metrics.aggregate_count(
+        :measure10_count,
+        :measure10,
+        "some other measure",
+        [:tag]
+      )
+
+      Metrics.record(:measure10, 1)
+
+      assert %{data: %{rows: [%{tags: ["value"]}]}, tags: [:tag]} =
+               capture_aggregate(:measure10_count)
+    end
+  end
+
+  defp record_measures(measure_name) when is_atom(measure_name) do
+    Metrics.record([{measure_name, 10}, {measure_name, 20}], %{t1: "a", t2: "A"})
+    Metrics.record(measure_name, %{t1: "b", t2: "B"}, 31)
+    Metrics.record(measure_name, %{t1: "b", t2: "B"}, 32)
+    Metrics.record(measure_name, %{t1: "b", t2: "B"}, 51)
+  end
+
+  defp capture_aggregate(name) do
+    Capture.capture_next()
+    |> Enum.find(fn
+      %{name: ^name} -> true
+      _ -> false
+    end)
+  end
+end
diff --git a/test/test_helper.exs b/test/test_helper.exs
index 5f12ee8..9d59bdf 100644
--- a/test/test_helper.exs
+++ b/test/test_helper.exs
@@ -9,4 +9,5 @@ ExUnit.configure(
 
 :application.ensure_all_started(:opencensus)
 :application.ensure_all_started(:telemetry)
+{:ok, _pid} = Opencensus.TestSupport.MetricsCaptureExporter.start_link()
 ExUnit.start()

From 40a5105b969c9e00e32b4572fa1550b8d5c5ddbf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Szczygie=C5=82?=
 <1153719+mszczygiel@users.noreply.github.com>
Date: Fri, 18 Oct 2019 21:13:10 +0200
Subject: [PATCH 3/8] readme was updated

---
 README.md                        | 27 ++++++++++++++++++++++++---
 test/opencensus_metrics_test.exs | 16 ++++++++++++++++
 2 files changed, 40 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index e96d601..7fb54bd 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@
 
 Wraps some [`:opencensus`][:opencensus] capabilities for Elixir users so
 they don't have to [learn them some Erlang][lyse] in order to get
-[OpenCensus] distributed tracing.
+[OpenCensus] distributed tracing and metrics.
 
 [opencensus]: http://opencensus.io
 [:opencensus]: https://hex.pm/packages/opencensus
@@ -25,6 +25,7 @@ end
 ```
 
 ## Usage
+### Tracing
 
 Wrap your code with the
 [`Opencensus.Trace.with_child_span/3`][oce-with_child_span-3] macro to
@@ -40,6 +41,20 @@ def traced_fn(arg) do
 end
 ```
 
+### Metrics
+
+Register measures, define aggregations, record measures:
+```elixir
+alias Opencensus.Metrics
+
+def foo do
+  Metrics.new_measure(:latency, "the latency in milliseconds", :milli_seconds)
+  Metrics.aggregate_count("request_count", :latency, "number of requests", [:protocol, :operation])
+  Metrics.aggregate_distribution("latencies_distribution", :latency, "distribution of latencies", [:protocol, :operation], [10, 50, 100, 500])
+  Metrics.record(:latency, %{protocol: :http, operation: :get_cats}, 121.2)
+end
+```
+
 ## Alternatives
 
 If you prefer driving Erlang packages directly (see also `:telemetry`), copy
@@ -74,16 +89,22 @@ end
 
 ## Troubleshooting
 
-To see your spans, use the `:oc_reporter_stdout` reporter, either in config:
+To see your spans, use the `:oc_reporter_stdout` reporter. To see your metrics, use the `:oc_stdout_exporter` exporter.
+You can set it either in config:
 
 ```elixir
-config :opencensus, reporters: [{:oc_reporter_stdout, []}]
+config :opencensus,
+  reporters: [{:oc_reporter_stdout, []}],
+  stat: [
+    exporters: [{:oc_stdout_exporter, []}]
+  ]
 ```
 
 ... or at the `iex` prompt:
 
 ```plain
 iex> :oc_reporter.register(:oc_reporter_stdout)
+iex> :oc_stat_exporter.register(:oc_stdout_exporter)
 ```
 
 [oce-with_child_span-3]: https://hexdocs.pm/opencensus_elixir/Opencensus.Trace.html#with_child_span/3
diff --git a/test/opencensus_metrics_test.exs b/test/opencensus_metrics_test.exs
index 8c5445d..df1fb4c 100644
--- a/test/opencensus_metrics_test.exs
+++ b/test/opencensus_metrics_test.exs
@@ -148,6 +148,22 @@ defmodule Opencensus.MetricsTest do
     end
   end
 
+  describe "create measure more than once" do
+    test "measurements should not be lost" do
+      Metrics.new_measure(:dup, "", :seconds)
+
+      Metrics.aggregate_count("dup_count", :dup, "dup count", [])
+
+      Metrics.record(:dup, 1)
+
+      Metrics.new_measure(:dup, "", :seconds)
+
+      Metrics.record(:dup, 1)
+
+      assert %{data: %{rows: [%{value: 2}]}} = capture_aggregate("dup_count")
+    end
+  end
+
   defp record_measures(measure_name) when is_atom(measure_name) do
     Metrics.record([{measure_name, 10}, {measure_name, 20}], %{t1: "a", t2: "A"})
     Metrics.record(measure_name, %{t1: "b", t2: "B"}, 31)

From cf04f7ea26ebcb858e3f22f840b360fb8b5a9f47 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Szczygie=C5=82?=
 <1153719+mszczygiel@users.noreply.github.com>
Date: Thu, 24 Oct 2019 20:35:19 +0200
Subject: [PATCH 4/8] rename new_measure -> new

---
 README.md                        |  2 +-
 lib/opencensus/metrics.ex        |  6 +++---
 test/opencensus_metrics_test.exs | 14 +++++++-------
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/README.md b/README.md
index 7fb54bd..5a7c216 100644
--- a/README.md
+++ b/README.md
@@ -48,7 +48,7 @@ Register measures, define aggregations, record measures:
 alias Opencensus.Metrics
 
 def foo do
-  Metrics.new_measure(:latency, "the latency in milliseconds", :milli_seconds)
+  Metrics.new(:latency, "the latency in milliseconds", :milli_seconds)
   Metrics.aggregate_count("request_count", :latency, "number of requests", [:protocol, :operation])
   Metrics.aggregate_distribution("latencies_distribution", :latency, "distribution of latencies", [:protocol, :operation], [10, 50, 100, 500])
   Metrics.record(:latency, %{protocol: :http, operation: :get_cats}, 121.2)
diff --git a/lib/opencensus/metrics.ex b/lib/opencensus/metrics.ex
index 4420636..63c696b 100644
--- a/lib/opencensus/metrics.ex
+++ b/lib/opencensus/metrics.ex
@@ -4,8 +4,8 @@ defmodule Opencensus.Metrics do
 
   First, a measure must be created:
   ```elixir
-  Metrics.new_measure(:name, "description", :unit)
-  Metrics.new_measure(:another, "", :unit)
+  Metrics.new(:name, "description", :unit)
+  Metrics.new(:another, "", :unit)
   ```
 
   Next step is to choose aggregations to be exported:
@@ -27,7 +27,7 @@ defmodule Opencensus.Metrics do
   ```
   """
 
-  def new_measure(name, description, unit) do
+  def new(name, description, unit) do
     :oc_stat_measure.new(name, description, unit)
   end
 
diff --git a/test/opencensus_metrics_test.exs b/test/opencensus_metrics_test.exs
index df1fb4c..d36261b 100644
--- a/test/opencensus_metrics_test.exs
+++ b/test/opencensus_metrics_test.exs
@@ -8,7 +8,7 @@ defmodule Opencensus.MetricsTest do
     test "counter" do
       measure_name = :measure1
       tag_names = [:t1, :t2]
-      Metrics.new_measure(measure_name, "A test measure", :milli_second)
+      Metrics.new(measure_name, "A test measure", :milli_second)
 
       Metrics.aggregate_count(
         :test_count,
@@ -37,7 +37,7 @@ defmodule Opencensus.MetricsTest do
 
     test "gauge" do
       measure_name = :measure2
-      Metrics.new_measure(measure_name, "A test measure", :milli_seconds)
+      Metrics.new(measure_name, "A test measure", :milli_seconds)
 
       Metrics.aggregate_gauge(:test_gauge, measure_name, "A gauge", [:t1, :t2])
 
@@ -61,7 +61,7 @@ defmodule Opencensus.MetricsTest do
 
     test "sum" do
       measure_name = :measure3
-      Metrics.new_measure(measure_name, "A test measure", :milli_seconds)
+      Metrics.new(measure_name, "A test measure", :milli_seconds)
       Metrics.aggregate_sum(:test_sum, measure_name, "A sum", [:t1, :t2])
 
       record_measures(measure_name)
@@ -84,7 +84,7 @@ defmodule Opencensus.MetricsTest do
 
     test "distribution" do
       measure_name = :measure4
-      Metrics.new_measure(measure_name, "A test measure", :milli_seconds)
+      Metrics.new(measure_name, "A test measure", :milli_seconds)
 
       Metrics.aggregate_distribution(
         :test_distribution,
@@ -132,7 +132,7 @@ defmodule Opencensus.MetricsTest do
   describe "using tags from process dictionary" do
     test "tag values are taken from process dictionary" do
       :ocp.with_tags(%{tag: "value"})
-      Metrics.new_measure(:measure10, "measure", :bytes)
+      Metrics.new(:measure10, "measure", :bytes)
 
       Metrics.aggregate_count(
         :measure10_count,
@@ -150,13 +150,13 @@ defmodule Opencensus.MetricsTest do
 
   describe "create measure more than once" do
     test "measurements should not be lost" do
-      Metrics.new_measure(:dup, "", :seconds)
+      Metrics.new(:dup, "", :seconds)
 
       Metrics.aggregate_count("dup_count", :dup, "dup count", [])
 
       Metrics.record(:dup, 1)
 
-      Metrics.new_measure(:dup, "", :seconds)
+      Metrics.new(:dup, "", :seconds)
 
       Metrics.record(:dup, 1)
 

From 3db26b8ab49ee225d4c0e2ca70fb868c92e2b43b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Szczygie=C5=82?=
 <1153719+mszczygiel@users.noreply.github.com>
Date: Thu, 24 Oct 2019 20:40:13 +0200
Subject: [PATCH 5/8] using defdelegate

---
 lib/opencensus/metrics.ex | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/lib/opencensus/metrics.ex b/lib/opencensus/metrics.ex
index 63c696b..a65b536 100644
--- a/lib/opencensus/metrics.ex
+++ b/lib/opencensus/metrics.ex
@@ -27,9 +27,7 @@ defmodule Opencensus.Metrics do
   ```
   """
 
-  def new(name, description, unit) do
-    :oc_stat_measure.new(name, description, unit)
-  end
+  defdelegate new(name, description, unit), to: :oc_stat_measure
 
   @doc """
   count of how many times `measure` was recorded will be exported

From f17dcc3cfc42bee556fc8a68b94350bb8330b851 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Szczygie=C5=82?=
 <1153719+mszczygiel@users.noreply.github.com>
Date: Thu, 24 Oct 2019 20:47:44 +0200
Subject: [PATCH 6/8] make tags last argument

---
 README.md                        | 2 +-
 lib/opencensus/metrics.ex        | 4 ++--
 test/opencensus_metrics_test.exs | 6 +++---
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index 5a7c216..455069b 100644
--- a/README.md
+++ b/README.md
@@ -51,7 +51,7 @@ def foo do
   Metrics.new(:latency, "the latency in milliseconds", :milli_seconds)
   Metrics.aggregate_count("request_count", :latency, "number of requests", [:protocol, :operation])
   Metrics.aggregate_distribution("latencies_distribution", :latency, "distribution of latencies", [:protocol, :operation], [10, 50, 100, 500])
-  Metrics.record(:latency, %{protocol: :http, operation: :get_cats}, 121.2)
+  Metrics.record(:latency, 121.2, %{protocol: :http, operation: :get_cats})
 end
 ```
 
diff --git a/lib/opencensus/metrics.ex b/lib/opencensus/metrics.ex
index a65b536..2622359 100644
--- a/lib/opencensus/metrics.ex
+++ b/lib/opencensus/metrics.ex
@@ -18,7 +18,7 @@ defmodule Opencensus.Metrics do
 
   After aggregations are decided, measures may be recorded by explicitly providing tags:
   ```elixir
-  Metrics.record(:name, %{tag1: "v1", tag2: "v2"}, 3)
+  Metrics.record(:name}, 3, %{tag1: "v1", tag2: "v2"})
   Metrics.record([another: 1, name: 100], %{tag1: "v1", tag2: "v2})
   ```
   or using tag values that are present in process dictionary:
@@ -66,7 +66,7 @@ defmodule Opencensus.Metrics do
   @doc """
   records single measure
   """
-  def record(measure, %{} = tags, value) when is_number(value) do
+  def record(measure, value, %{} = tags) when is_number(value) do
     :oc_stat.record(tags, measure, value)
   end
 
diff --git a/test/opencensus_metrics_test.exs b/test/opencensus_metrics_test.exs
index d36261b..7edd98e 100644
--- a/test/opencensus_metrics_test.exs
+++ b/test/opencensus_metrics_test.exs
@@ -166,9 +166,9 @@ defmodule Opencensus.MetricsTest do
 
   defp record_measures(measure_name) when is_atom(measure_name) do
     Metrics.record([{measure_name, 10}, {measure_name, 20}], %{t1: "a", t2: "A"})
-    Metrics.record(measure_name, %{t1: "b", t2: "B"}, 31)
-    Metrics.record(measure_name, %{t1: "b", t2: "B"}, 32)
-    Metrics.record(measure_name, %{t1: "b", t2: "B"}, 51)
+    Metrics.record(measure_name, 31, %{t1: "b", t2: "B"})
+    Metrics.record(measure_name, 32, %{t1: "b", t2: "B"})
+    Metrics.record(measure_name, 51, %{t1: "b", t2: "B"})
   end
 
   defp capture_aggregate(name) do

From d81582bcc14b4da67988d2aa5dafd5bdcf80921d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Szczygie=C5=82?=
 <1153719+mszczygiel@users.noreply.github.com>
Date: Thu, 24 Oct 2019 20:54:20 +0200
Subject: [PATCH 7/8] accepting keyword list as tags

---
 lib/opencensus/metrics.ex        | 12 +++++++++++-
 test/opencensus_metrics_test.exs |  4 ++--
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/lib/opencensus/metrics.ex b/lib/opencensus/metrics.ex
index 2622359..af35ba4 100644
--- a/lib/opencensus/metrics.ex
+++ b/lib/opencensus/metrics.ex
@@ -19,7 +19,7 @@ defmodule Opencensus.Metrics do
   After aggregations are decided, measures may be recorded by explicitly providing tags:
   ```elixir
   Metrics.record(:name}, 3, %{tag1: "v1", tag2: "v2"})
-  Metrics.record([another: 1, name: 100], %{tag1: "v1", tag2: "v2})
+  Metrics.record([another: 1, name: 100], tag1: "v1", tag2: "v2)
   ```
   or using tag values that are present in process dictionary:
   ```elixir
@@ -70,6 +70,11 @@ defmodule Opencensus.Metrics do
     :oc_stat.record(tags, measure, value)
   end
 
+  def record(measure, value, tags) when is_list(tags) and is_number(value) do
+    tags = Enum.into(tags, %{})
+    record(measure, value, tags)
+  end
+
   @doc """
   records multiple measures
   """
@@ -77,6 +82,11 @@ defmodule Opencensus.Metrics do
     :oc_stat.record(tags, measures)
   end
 
+  def record(measures, tags) when is_list(measures) and is_list(tags) do
+    tags = Enum.into(tags, %{})
+    record(measures, tags)
+  end
+
   @doc """
   records single measure, takes tags from process dictionary
   """
diff --git a/test/opencensus_metrics_test.exs b/test/opencensus_metrics_test.exs
index 7edd98e..5a63541 100644
--- a/test/opencensus_metrics_test.exs
+++ b/test/opencensus_metrics_test.exs
@@ -165,10 +165,10 @@ defmodule Opencensus.MetricsTest do
   end
 
   defp record_measures(measure_name) when is_atom(measure_name) do
-    Metrics.record([{measure_name, 10}, {measure_name, 20}], %{t1: "a", t2: "A"})
+    Metrics.record([{measure_name, 10}, {measure_name, 20}], t1: "a", t2: "A")
     Metrics.record(measure_name, 31, %{t1: "b", t2: "B"})
     Metrics.record(measure_name, 32, %{t1: "b", t2: "B"})
-    Metrics.record(measure_name, 51, %{t1: "b", t2: "B"})
+    Metrics.record(measure_name, 51, t1: "b", t2: "B")
   end
 
   defp capture_aggregate(name) do

From e909dab2a884d87978bb0d09be4f2221527ad89c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Szczygie=C5=82?=
 <1153719+mszczygiel@users.noreply.github.com>
Date: Thu, 24 Oct 2019 20:56:25 +0200
Subject: [PATCH 8/8] make tests async

---
 test/opencensus_metrics_test.exs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/opencensus_metrics_test.exs b/test/opencensus_metrics_test.exs
index 5a63541..917ca9f 100644
--- a/test/opencensus_metrics_test.exs
+++ b/test/opencensus_metrics_test.exs
@@ -2,7 +2,7 @@ defmodule Opencensus.MetricsTest do
   alias Opencensus.Metrics
   alias Opencensus.TestSupport.MetricsCaptureExporter, as: Capture
 
-  use ExUnit.Case, async: false
+  use ExUnit.Case, async: true
 
   describe "Aggregate measurements" do
     test "counter" do