feat: open telemetry

.github/workflows/ci.yml

@@ -31,8 +31,8 @@ jobs:
       - name: Set up Elixir
         uses: erlef/setup-beam@v1
         with:
-          elixir-version: "1.14.3"
-          otp-version: "24.3"
+          elixir-version: "1.15.6"
+          otp-version: "26.1"
       - name: Restore dependencies cache
         uses: actions/cache@v3
         with:

.tool-versions

@@ -1,2 +1,2 @@
-elixir 1.14.3-otp-25
-erlang 25.2
+elixir 1.15.6-otp-26
+erlang 26.1.1

CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+# v2.0.2 - 2023-10-09
+
+### Added
+
+- OpenTelemetry to export telemetry.
+- Jason for json decoding.
+
+### Changed
+
+- Upgraded dependencies: ssl_verify_fun: 1.1.7, timex: 3.7.11
+
+### Removed
+
+- Removed dependencies: excoveralls, poison
+
 # v2.0.1 - 2023-03-13
 
 ### Added

Dockerfile

@@ -1,4 +1,4 @@
-FROM codedgellc/alpine-elixir-phoenix:1.14 as builder
+FROM elixir:1.15 as builder
 
 WORKDIR /tarot_cup
 

config/config.exs

@@ -4,4 +4,6 @@ config :logger, :console,
   format: "$time $metadata[$level] $message\n",
   metadata: [:request_id]
 
+config :opentelemetry, traces_exporter: :none
+
 import_config("#{Mix.env()}.exs")

config/runtime.exs

@@ -0,0 +1,24 @@
+import Config
+
+if config_env() == :prod do
+  config :nostrum,
+    token: System.fetch_env!("DISCORD_TOKEN")
+
+  if System.get_env("OTLP_ENDPOINT") do
+    config :opentelemetry,
+      span_processor: :batch,
+      traces_exporter: :otlp
+
+    config :opentelemetry_exporter,
+      otlp_protocol: :http_protobuf,
+      otlp_endpoint: System.get_env("OTLP_ENDPOINT")
+  end
+
+  # Optional
+
+  config :logger, level: String.to_atom(System.get_env("LOG_LEVEL", "info"))
+
+  config :tarot_cup,
+    datadir: System.get_env("DATADIR", ""),
+    local_images?: System.get_env("LOCAL_IMAGES")
+end

config/test.exs

@@ -1,4 +1,4 @@
-use Mix.Config
+import Config
 
 # We don't run a server during test. If one is required,
 # you can enable the server option below.

lib/tarot_cup/game.ex

@@ -11,33 +11,39 @@ defmodule TarotCup.Game do
     Rule
   }
 
+  require OpenTelemetry.Tracer
+
   def new do
-    cards = Enum.shuffle(TarotCup.Card.all_ids())
-
-    %__MODULE__{
-      id: UUID.uuid4(),
-      unplayed_cards: cards,
-      started_at: DateTime.utc_now(),
-      last_activity: DateTime.utc_now()
-    }
+    OpenTelemetry.Tracer.with_span :game_new do
+      cards = Enum.shuffle(TarotCup.Card.all_ids())
+
+      %__MODULE__{
+        id: UUID.uuid4(),
+        unplayed_cards: cards,
+        started_at: DateTime.utc_now(),
+        last_activity: DateTime.utc_now()
+      }
+    end
   end
 
   def draw(%{unplayed_cards: []}) do
     {:error, :finished}
   end
 
   def draw(%{unplayed_cards: u_cards, played_cards: p_cards} = game) do
-    [card_id | rest] = u_cards
-    card = Card.get(card_id)
-    card = Map.put(card, "description", Rule.get(card["rule_id"])["description"])
-
-    {:ok, card,
-     %{
-       game
-       | unplayed_cards: rest,
-         played_cards: [card_id | p_cards],
-         finished?: rest == []
-     }}
+    OpenTelemetry.Tracer.with_span :game_draw do
+      [card_id | rest] = u_cards
+      card = Card.get(card_id)
+      card = Map.put(card, "description", Rule.get(card["rule_id"])["description"])
+
+      {:ok, card,
+       %{
+         game
+         | unplayed_cards: rest,
+           played_cards: [card_id | p_cards],
+           finished?: rest == []
+       }}
+    end
   end
 
   def update_last_activity(game) do

lib/tarot_cup/game_server.ex

@@ -5,6 +5,8 @@ defmodule TarotCup.GameServer do
     Rule
   }
 
+  require OpenTelemetry.Tracer
+
   @table :games
 
   def total do
@@ -21,55 +23,67 @@ defmodule TarotCup.GameServer do
   end
 
   def reset(name) do
-    game = Game.new()
-    save(name, game)
-    {:ok, game}
+    OpenTelemetry.Tracer.with_span :game_server_reset do
+      game = Game.new()
+      save(name, game)
+      {:ok, game}
+    end
   end
 
   def draw(name) do
-    game = get(name) || Game.new()
+    OpenTelemetry.Tracer.with_span :game_server_draw do
+      game = get(name) || Game.new()
 
-    case Game.draw(game) do
-      {:ok, card, updated_game} ->
-        save(name, updated_game)
-        {:ok, card}
+      case Game.draw(game) do
+        {:ok, card, updated_game} ->
+          save(name, updated_game)
+          {:ok, card}
 
-      {:error, :finished} ->
-        {:error, :finished}
+        {:error, :finished} ->
+          {:error, :finished}
+      end
     end
   end
 
   def peek(name, amount) do
-    case get(name) do
-      nil ->
-        {:error, :nogame}
+    OpenTelemetry.Tracer.with_span :game_server_peek do
+      case get(name) do
+        nil ->
+          {:error, :nogame}
 
-      game ->
-        cards =
-          game.unplayed_cards
-          |> Enum.take(amount)
-          |> Enum.map(fn card_id ->
-            card = Card.get(card_id)
-            Map.put(card, "description", Rule.get(card["rule_id"])["description"])
-          end)
+        game ->
+          cards =
+            game.unplayed_cards
+            |> Enum.take(amount)
+            |> Enum.map(fn card_id ->
+              card = Card.get(card_id)
+              Map.put(card, "description", Rule.get(card["rule_id"])["description"])
+            end)
 
-        {:ok, cards}
+          {:ok, cards}
+      end
     end
   end
 
   def save(name, game) do
-    game = Game.update_last_activity(game)
-    :ets.insert(@table, [{{:game, name}, game}])
+    OpenTelemetry.Tracer.with_span :game_server_save do
+      game = Game.update_last_activity(game)
+      :ets.insert(@table, [{{:game, name}, game}])
+    end
   end
 
   def get(name) do
-    case :ets.lookup(@table, {:game, name}) do
-      [] -> nil
-      [{{:game, _name}, game}] -> game
+    OpenTelemetry.Tracer.with_span :game_server_get do
+      case :ets.lookup(@table, {:game, name}) do
+        [] -> nil
+        [{{:game, _name}, game}] -> game
+      end
     end
   end
 
   def delete(name) do
-    :ets.delete(@table, {:game, name})
+    OpenTelemetry.Tracer.with_span :game_server_delete do
+      :ets.delete(@table, {:game, name})
+    end
   end
 end

lib/tarot_cup/handler/game.ex

@@ -3,74 +3,83 @@ defmodule TarotCup.Handler.Game do
   alias Nostrum.Struct.Embed
   alias TarotCup.GameServer
   require Logger
+  require OpenTelemetry.Tracer
 
   @yellow 0xF7DC54
 
   def handle_draw(interaction) do
-    interaction.channel_id
-    |> GameServer.draw()
-    |> case do
-      {:ok, card} ->
-        case card do
-          %{"id" => "16-tower"} ->
-            cards =
-              interaction.channel_id
-              |> GameServer.peek(3)
-              |> elem(1)
-              |> Enum.map(& &1["name"])
-              |> Enum.join(", ")
-
-            {:ok, chan} = Api.create_dm(interaction.user.id)
-            Api.create_message(chan.id, cards)
-
-          _else ->
-            :ok
-        end
-
-        embed = card_embed(card, interaction.user.id)
-        file = image_path(card)
-
-        response = %{type: 4, data: %{file: file, embeds: [embed]}}
-        Api.create_interaction_response(interaction, response)
-
-      {:error, :finished} ->
-        msg = "Game is already over, !reset to start a new game."
-        response = %{type: 4, data: %{content: msg}}
-        Api.create_interaction_response(interaction, response)
+    OpenTelemetry.Tracer.with_span :game_handle_draw do
+      interaction.channel_id
+      |> GameServer.draw()
+      |> case do
+        {:ok, card} ->
+          case card do
+            %{"id" => "16-tower"} ->
+              cards =
+                interaction.channel_id
+                |> GameServer.peek(3)
+                |> elem(1)
+                |> Enum.map(& &1["name"])
+                |> Enum.join(", ")
+
+              {:ok, chan} = Api.create_dm(interaction.user.id)
+              Api.create_message(chan.id, cards)
+
+            _else ->
+              :ok
+          end
+
+          embed = card_embed(card, interaction.user.id)
+          file = image_path(card)
+
+          response = %{type: 4, data: %{file: file, embeds: [embed]}}
+          Api.create_interaction_response(interaction, response)
+
+        {:error, :finished} ->
+          msg = "Game is already over, !reset to start a new game."
+          response = %{type: 4, data: %{content: msg}}
+          Api.create_interaction_response(interaction, response)
+      end
     end
   end
 
   def handle_bet(interaction, count) do
-    [result] =
-      Enum.take_random(
-        [
-          "Congrats! Everyone else drinks #{count}.",
-          "Ooof, you gotta drink #{count}."
-        ],
-        1
-      )
-
-    response = %{type: 4, data: %{content: result}}
-    Api.create_interaction_response(interaction, response)
+    OpenTelemetry.Tracer.with_span :game_handle_bet do
+      [result] =
+        Enum.take_random(
+          [
+            "Congrats! Everyone else drinks #{count}.",
+            "Ooof, you gotta drink #{count}."
+          ],
+          1
+        )
+
+      response = %{type: 4, data: %{content: result}}
+      Api.create_interaction_response(interaction, response)
+    end
   end
 
   def handle_reset(interaction) do
-    GameServer.reset(interaction.channel_id)
+    OpenTelemetry.Tracer.with_span :game_handle_reset do
+      GameServer.reset(interaction.channel_id)
 
-    response = %{type: 4, data: %{content: "A new deck is ready."}}
-    Api.create_interaction_response(interaction, response)
+      response = %{type: 4, data: %{content: "A new deck is ready."}}
+      Api.create_interaction_response(interaction, response)
+    end
   end
 
   def handle_status(interaction) do
-    response =
-      interaction.channel_id
-      |> GameServer.status()
-      |> case do
-        {:ok, game} -> %{type: 4, data: %{embeds: [game_embed(game)]}}
-        {:error, :nogame} -> %{type: 4, data: %{content: "No active game. /draw to start one."}}
-      end
+    OpenTelemetry.Tracer.with_span :game_handle_status do
+      response =
+        interaction.channel_id
+        |> GameServer.status()
+        |> case do
+          {:ok, game} -> %{type: 4, data: %{embeds: [game_embed(game)]}}
+          {:error, :nogame} -> %{type: 4, data: %{content: "No active game. /draw to start one."}}
+        end
 
-    Api.create_interaction_response(interaction, response)
+      Api.create_interaction_response(interaction, response)
+    end
   end
 
   defp card_embed(card, author) do