Adding open telemetry

config/config.exs

@@ -0,0 +1,8 @@
+use Mix.Config
+
+config :opentelemetry, :processors,
+  otel_batch_processor: %{
+    exporter:
+      {:opentelemetry_zipkin,
+       %{address: "http://localhost:9411/api/v2/spans", local_endpoint: %{service_name: "glance"}}}
+  }

docker-compose.yml

@@ -19,3 +19,7 @@ services:
     network_mode: host
     environment:
       PORT: 9000
+  zipkin:
+    image: openzipkin/zipkin
+    ports:
+      - 9411:9411

lib/glance/application.ex

@@ -6,10 +6,13 @@ defmodule Glance.Application do
   def start(_type, _args) do
     port = port()
 
+    true = OpenTelemetry.register_application_tracer(:glance)
+    tracer = OpenTelemetry.get_tracer(:glance)
+
     children = [
       %{
         id: :cowboy,
-        start: {:gleam@http@cowboy, :start, [&:glance@web@router.handle(&1, nil), port]}
+        start: {:gleam@http@cowboy, :start, [&:glance@web@router.handle(&1, tracer), port]}
       }
     ]
 

mix.exs

@@ -33,7 +33,10 @@ defmodule PlumMail.MixProject do
        github: "midas-framework/floki",
        tag: "4bae91f3129fbf517aae084695db5671eb115931",
        manager: :mix,
-       override: true}
+       override: true},
+      {:opentelemetry_zipkin, "~> 0.4.0"},
+      {:opentelemetry, "~> 0.5.0"},
+      {:opentelemetry_api, "~> 0.5.0"}
     ]
   end
 end

mix.lock

@@ -11,5 +11,8 @@
   "html_entities": {:hex, :html_entities, "0.5.1", "1c9715058b42c35a2ab65edc5b36d0ea66dd083767bef6e3edb57870ef556549", [:mix], [], "hexpm", "30efab070904eb897ff05cd52fa61c1025d7f8ef3a9ca250bc4e6513d16c32de"},
   "jsone": {:hex, :jsone, "1.5.2", "87adea283c9cf24767b4deed44602989a5331156df5d60a2660e9c9114d54046", [:rebar3], [], "hexpm", "170c171ce7f6dd70c858065154a3305b8564833c6dcca17e10b676ca31ea976f"},
   "mix_gleam": {:hex, :mix_gleam, "0.1.0", "a0cee5d30de865124a32ca6cd53b64c3e2ac57f12adf6e47b88fb673f47c716e", [:mix], [], "hexpm", "9ff518e6aab444c7f2e74038f9383020ef89810cf1f4402911f33b202ffd72e7"},
+  "opentelemetry": {:hex, :opentelemetry, "0.5.0", "6a7072a6f54b8be07a42dd2aaca1ee0389038681405d0a27c4c5e5325b6c1a82", [:rebar3], [{:opentelemetry_api, "~>0.5.0", [hex: :opentelemetry_api, repo: "hexpm", optional: false]}], "hexpm", "a45261c421240199184d55447108f1d9f49c6b2b0e0e2056aaaa1a1fe77d2eda"},
+  "opentelemetry_api": {:hex, :opentelemetry_api, "0.5.0", "29ecaa7bb86df4dbd44b14fd71fd4faadff5c08d178545b66b3861bd350be28a", [:mix, :rebar3], [], "hexpm", "fa3c23198e84d6d1cdb8a4408374c8d73c9d2ee7a9e587a6d539def15851ffad"},
+  "opentelemetry_zipkin": {:hex, :opentelemetry_zipkin, "0.4.0", "868ce254d03f43d0ebeb1952e80b4b0a6cef72ae5e85d8c3bffe3a0cb48516fa", [:rebar3], [{:opentelemetry, "~>0.5.0", [hex: :opentelemetry, repo: "hexpm", optional: false]}, {:opentelemetry_api, "~>0.5.0", [hex: :opentelemetry_api, repo: "hexpm", optional: false]}], "hexpm", "6384d3aca2c39f9c67c9c17c1bac445f6f693326d3c96cd1443ea43dbdd2dd21"},
   "ranch": {:hex, :ranch, "1.7.1", "6b1fab51b49196860b733a49c07604465a47bdb78aa10c1c16a3d199f7f8c881", [:rebar3], [], "hexpm", "451d8527787df716d99dc36162fca05934915db0b6141bbdac2ea8d3c7afc7d7"},
 }

src/glance/strategy/google_photos.gleam

@@ -10,12 +10,13 @@ pub fn apply(document) {
     // The first image is always a profile image
     |> list.drop(1)
 
-  let image_sources = floki.attribute(image_tags, "src")
-  |> list.map(fn(src) {
+  let image_sources =
+    floki.attribute(image_tags, "src")
+    |> list.map(fn(src) {
       // The images are all cropped to a tumbnail
       assert [uncropped, _] = string.split(src, "=")
       uncropped
-  })
+    })
   assert Ok(title) = default.get_og_title(document)
   ImageReel(title: title, images: image_sources)
 }

src/glance/web/router.gleam

@@ -1,3 +1,4 @@
+import gleam/atom
 import gleam/bit_builder.{BitBuilder}
 import gleam/bit_string.{BitString}
 import gleam/io
@@ -8,6 +9,8 @@ import gleam/http.{Request, Response}
 import gleam/httpc
 import gleam/json
 import floki
+import open_telemetry
+import open_telemetry/http as otel_http
 import glance/strategy/strategy
 import glance/snapshot
 
@@ -23,32 +26,60 @@ pub fn set_resp_json(response, data) {
   |> http.set_resp_body(body)
 }
 
-pub fn handle(request: Request(BitString), config: Nil) -> Response(BitBuilder) {
-  case request.method {
-    http.Options ->
-      http.response(200)
-      |> http.set_resp_body(bit_builder.from_bit_string(<<>>))
-    _ ->
-      case request.query {
-        Some(target) -> {
-          assert Ok(uri.Uri(path: path, host: Some(host), ..)) =
-            uri.parse(target)
-          let req =
-            http.default_req()
-            |> http.set_method(http.Get)
-            |> http.set_host(host)
-            |> http.set_path(path)
-          assert Ok(Response(status: 200, body: html, ..)) = httpc.send(req)
-          assert Ok(document) = floki.parse_document(html)
-          let snapshot = strategy.apply(host, document)
-          http.response(200)
-          |> set_resp_json(json.object([
-            tuple("snapshot", snapshot.to_json(snapshot)),
-          ]))
+pub fn handle(
+  request: Request(BitString),
+  tracer: open_telemetry.Tracer,
+) -> Response(BitBuilder) {
+  open_telemetry.with_span(
+    tracer,
+    "HTTP.SERVER",
+    fn(span_context) {
+      open_telemetry.set_attributes(
+        span_context,
+        otel_http.request_attributes(request),
+      )
+      let response =
+        case request.method {
+          http.Options ->
+            http.response(200)
+            |> http.set_resp_body(bit_builder.from_bit_string(<<>>))
+          _ ->
+            case request.query {
+              Some(target) -> {
+                assert Ok(uri.Uri(path: path, host: Some(host), ..)) =
+                  uri.parse(target)
+                  // Run the span on the client call
+                assert Ok(Response(status: 200, body: html, ..)) = open_telemetry.with_span(tracer, "HTTP.CLIENT", fn(span_context) {
+                    let req =
+                    http.default_req()
+                    |> http.set_method(http.Get)
+                    |> http.set_host(host)
+                    |> http.set_path(path)
+                    httpc.send(req)
+                })
+                  // Run the span on the parsing step
+                let snapshot = open_telemetry.with_span(tracer, "PARSE SNAPSHOT", fn(span_context) {
+                    assert Ok(document) = floki.parse_document(html)
+                    strategy.apply(host, document)
+                })
+                http.response(200)
+                |> set_resp_json(json.object([
+                  tuple("snapshot", snapshot.to_json(snapshot)),
+                ]))
+              }
+            }
         }
-      }
-  }
-  |> http.prepend_resp_header("access-control-allow-origin", "*")
-  |> http.prepend_resp_header("access-control-allow-credentials", "true")
-  |> http.prepend_resp_header("access-control-allow-headers", "content-type")
+        |> http.prepend_resp_header("access-control-allow-origin", "*")
+        |> http.prepend_resp_header("access-control-allow-credentials", "true")
+        |> http.prepend_resp_header(
+          "access-control-allow-headers",
+          "content-type",
+        )
+      open_telemetry.set_attributes(
+        span_context,
+        otel_http.response_attributes(response),
+      )
+      response
+    },
+  )
 }

src/open_telemetry.gleam

@@ -0,0 +1,28 @@
+import gleam/atom.{Atom}
+
+pub external type Tracer
+
+pub external type SpanContext
+
+pub external fn get_tracer(name: Atom) -> Tracer =
+  "opentelemetry" "get_tracer"
+
+pub external fn with_span(
+  tracer: Tracer,
+  name: String,
+  func: fn(SpanContext) -> t,
+) -> t =
+  "otel_tracer" "with_span"
+
+pub external fn set_attribute(
+  span: SpanContext,
+  key: String,
+  value: String,
+) -> Nil =
+  "otel_span" "set_attribute"
+
+pub external fn set_attributes(
+  span: SpanContext,
+  attributes: List(tuple(String, String)),
+) -> Nil =
+  "otel_span" "set_attributes"

src/open_telemetry/http.gleam

@@ -0,0 +1,28 @@
+import gleam/int
+import gleam/option
+import gleam/string
+import gleam/http.{Request, Response}
+
+pub fn request_attributes(request: Request(a)) {
+  let scheme = http.scheme_to_string(request.scheme)
+  let host = request.host
+  let path = request.path
+  // TODO decide if empty string is a good idea when query missing
+  let query = option.unwrap(request.query, "")
+  let method = string.uppercase(http.method_to_string(request.method))
+  assert Ok(user_agent) = http.get_req_header(request, "user-agent")
+  [
+    tuple("http.scheme", scheme),
+    tuple("http.method", method),
+    tuple("http.host", host),
+    tuple("http.path", path),
+    tuple("http.query", query),
+    tuple("http.user_agent", user_agent),
+  ]
+}
+
+pub fn response_attributes(response: Response(a)) {
+  let status_code = int.to_string(response.status)
+  [tuple("http.status_code", status_code)]
+  // TODO set status as ok
+}