you know it

examples/complete/gleam.toml

···
 [dependencies]
 gleam_stdlib = "~> 0.34 or ~> 1.0"
 mist = { path = "../.." }
+glisten = { path = "../../../glisten" }
 gleam_erlang = "~> 0.24"
 gleam_http = "~> 3.5"
 gleam_otp = "~> 0.9"
+logging = "~> 1.0"
 
 [dev-dependencies]
 gleeunit = "~> 1.0"

examples/complete/manifest.toml

···
 # You typically do not need to edit this file
 
 packages = [
-  { name = "birl", version = "1.6.0", build_tools = ["gleam"], requirements = ["gleam_stdlib", "ranger"], otp_app = "birl", source = "hex", outer_checksum = "0757CFE97DA52F19BC3262AC3DD284D9DAD2718D4C1830888DE483FB147477D4" },
+  { name = "birl", version = "1.6.1", build_tools = ["gleam"], requirements = ["gleam_stdlib", "ranger"], otp_app = "birl", source = "hex", outer_checksum = "976CFF85D34D50F7775896615A71745FBE0C325E50399787088F941B539A0497" },
   { name = "gleam_erlang", version = "0.25.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_erlang", source = "hex", outer_checksum = "054D571A7092D2A9727B3E5D183B7507DAB0DA41556EC9133606F09C15497373" },
   { name = "gleam_http", version = "3.6.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_http", source = "hex", outer_checksum = "8C07DF9DF8CC7F054C650839A51C30A7D3C26482AC241C899C1CEA86B22DBE51" },
   { name = "gleam_otp", version = "0.10.0", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_stdlib"], otp_app = "gleam_otp", source = "hex", outer_checksum = "0B04FE915ACECE539B317F9652CAADBBC0F000184D586AAAF2D94C100945D72B" },
   { name = "gleam_stdlib", version = "0.36.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "C0D14D807FEC6F8A08A7C9EF8DFDE6AE5C10E40E21325B2B29365965D82EB3D4" },
-  { name = "gleeunit", version = "1.0.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "D364C87AFEB26BDB4FB8A5ABDE67D635DC9FA52D6AB68416044C35B096C6882D" },
-  { name = "glisten", version = "2.0.0", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_otp", "gleam_stdlib"], otp_app = "glisten", source = "hex", outer_checksum = "CF3A9383E9BA4A8CBAF2F7B799716290D02F2AC34E7A77556B49376B662B9314" },
+  { name = "gleeunit", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "72CDC3D3F719478F26C4E2C5FED3E657AC81EC14A47D2D2DEBB8693CA3220C3B" },
+  { name = "glisten", version = "2.0.0", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_otp", "gleam_stdlib", "logging", "telemetry"], source = "local", path = "../../../glisten" },
   { name = "hpack_erl", version = "0.3.0", build_tools = ["rebar3"], requirements = [], otp_app = "hpack", source = "hex", outer_checksum = "D6137D7079169D8C485C6962DFE261AF5B9EF60FBC557344511C1E65E3D95FB0" },
   { name = "logging", version = "1.0.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "logging", source = "hex", outer_checksum = "82C112ED9B6C30C1772A6FE2613B94B13F62EA35F5869A2630D13948D297BD39" },
   { name = "mist", version = "1.0.0", build_tools = ["gleam"], requirements = ["birl", "gleam_erlang", "gleam_http", "gleam_otp", "gleam_stdlib", "glisten", "hpack_erl", "logging"], source = "local", path = "../.." },
-  { name = "ranger", version = "1.1.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "ranger", source = "hex", outer_checksum = "28E615AE7590ED922AF1510DDF606A2ECBBC2A9609AF36D412EDC925F06DFD20" },
+  { name = "ranger", version = "1.2.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "ranger", source = "hex", outer_checksum = "1566C272B1D141B3BBA38B25CB761EF56E312E79EC0E2DFD4D3C19FB0CC1F98C" },
+  { name = "telemetry", version = "1.2.1", build_tools = ["rebar3"], requirements = [], otp_app = "telemetry", source = "hex", outer_checksum = "DAD9CE9D8EFFC621708F99EAC538EF1CBE05D6A874DD741DE2E689C47FEAFED5" },
 ]
 
 [requirements]
···
 gleam_otp = { version = "~> 0.9" }
 gleam_stdlib = { version = "~> 0.34 or ~> 1.0" }
 gleeunit = { version = "~> 1.0" }
+glisten = { path = "../../../glisten" }
+logging = { version = "~> 1.0" }
 mist = { path = "../.." }

examples/complete/src/complete.gleam

···
 import gleam/otp/actor
 import gleam/result
 import gleam/string
+import glisten
 import mist.{type Connection, type ResponseData}
+import logging
 
 @external(erlang, "logger", "update_primary_config")
 fn logger_update_primary_config(config: Dict(Atom, Atom)) -> Result(Nil, any)
 
 pub fn main() {
+  logging.configure()
   logger_update_primary_config(
     dict.from_list([
       #(atom.create_from_string("level"), atom.create_from_string("debug")),
     ]),
   )
+  // glisten.configure_logger()
+  // mist.configure_logger()
   // These values are for the Websocket process initialized below
   let selector = process.new_selector()
   let state = Nil

gleam.toml

···
 hpack_erl = "~> 0.3"
 birl = "~> 1.3"
 logging = "~> 1.0"
-glisten = "~> 2.0"
+# glisten = "~> 2.0"
+glisten = { path = "../glisten" }
 
 [dev-dependencies]
 gleeunit = "~> 1.0"

manifest.toml

···
   { name = "gleam_otp", version = "0.10.0", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_stdlib"], otp_app = "gleam_otp", source = "hex", outer_checksum = "0B04FE915ACECE539B317F9652CAADBBC0F000184D586AAAF2D94C100945D72B" },
   { name = "gleam_stdlib", version = "0.36.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "C0D14D807FEC6F8A08A7C9EF8DFDE6AE5C10E40E21325B2B29365965D82EB3D4" },
   { name = "gleeunit", version = "1.0.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "D364C87AFEB26BDB4FB8A5ABDE67D635DC9FA52D6AB68416044C35B096C6882D" },
-  { name = "glisten", version = "2.0.0", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_otp", "gleam_stdlib"], otp_app = "glisten", source = "hex", outer_checksum = "CF3A9383E9BA4A8CBAF2F7B799716290D02F2AC34E7A77556B49376B662B9314" },
+  { name = "glisten", version = "2.0.0", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_otp", "gleam_stdlib", "logging", "telemetry"], source = "local", path = "../glisten" },
   { name = "hackney", version = "1.20.1", build_tools = ["rebar3"], requirements = ["certifi", "idna", "metrics", "mimerl", "parse_trans", "ssl_verify_fun", "unicode_util_compat"], otp_app = "hackney", source = "hex", outer_checksum = "FE9094E5F1A2A2C0A7D10918FEE36BFEC0EC2A979994CFF8CFE8058CD9AF38E3" },
   { name = "hpack_erl", version = "0.3.0", build_tools = ["rebar3"], requirements = [], otp_app = "hpack", source = "hex", outer_checksum = "D6137D7079169D8C485C6962DFE261AF5B9EF60FBC557344511C1E65E3D95FB0" },
   { name = "idna", version = "6.1.1", build_tools = ["rebar3"], requirements = ["unicode_util_compat"], otp_app = "idna", source = "hex", outer_checksum = "92376EB7894412ED19AC475E4A86F7B413C1B9FBB5BD16DCCD57934157944CEA" },
···
   { name = "parse_trans", version = "3.4.1", build_tools = ["rebar3"], requirements = [], otp_app = "parse_trans", source = "hex", outer_checksum = "620A406CE75DADA827B82E453C19CF06776BE266F5A67CFF34E1EF2CBB60E49A" },
   { name = "ranger", version = "1.1.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "ranger", source = "hex", outer_checksum = "28E615AE7590ED922AF1510DDF606A2ECBBC2A9609AF36D412EDC925F06DFD20" },
   { name = "ssl_verify_fun", version = "1.1.7", build_tools = ["mix", "rebar3", "make"], requirements = [], otp_app = "ssl_verify_fun", source = "hex", outer_checksum = "FE4C190E8F37401D30167C8C405EDA19469F34577987C76DDE613E838BBC67F8" },
+  { name = "telemetry", version = "1.2.1", build_tools = ["rebar3"], requirements = [], otp_app = "telemetry", source = "hex", outer_checksum = "DAD9CE9D8EFFC621708F99EAC538EF1CBE05D6A874DD741DE2E689C47FEAFED5" },
   { name = "unicode_util_compat", version = "0.7.0", build_tools = ["rebar3"], requirements = [], otp_app = "unicode_util_compat", source = "hex", outer_checksum = "25EEE6D67DF61960CF6A794239566599B09E17E668D3700247BC498638152521" },
 ]
 
···
 gleam_otp = { version = "~> 0.9" }
 gleam_stdlib = { version = "~> 0.35 or ~> 1.0" }
 gleeunit = { version = "~> 1.0" }
-glisten = { version = "~> 2.0"}
+glisten = { path = "../glisten" }
 hpack_erl = { version = "~> 0.3" }
 logging = { version = "~> 1.0" }

src/mist.gleam

···
   Chunked as InternalChunked, File as InternalFile,
   ServerSentEvents as InternalServerSentEvents, Websocket as InternalWebsocket,
 }
+import mist/internal/telemetry
 import mist/internal/websocket.{
   type HandlerMessage, type WebsocketConnection as InternalWebsocketConnection,
   BinaryFrame, Data, Internal, TextFrame, User,
···
   |> result.replace(Nil)
   |> result.nil_error
 }
+
+pub fn configure_logger() {
+  telemetry.attach_many("mist-logger", telemetry.events, telemetry.log)
+}

src/mist/internal/file.gleam

···
 
 @external(erlang, "filelib", "file_size")
 fn size(path: BitArray) -> Int
+
+@external(erlang, "mist_ffi", "file_close")
+pub fn close(file: FileDescriptor) -> Result(Nil, FileError)

src/mist/internal/handler.gleam

···
+import gleam/dict
 import gleam/erlang/process.{type Selector, type Subject}
 import gleam/function
 import gleam/http/response
···
 import mist/internal/http/handler as http_handler
 import mist/internal/http2/handler.{type Message, Send} as http2_handler
 import mist/internal/http2
+import mist/internal/telemetry
 import logging
 
 pub type HandlerError {
···
           Some(t) -> process.cancel_timer(t)
           _ -> process.TimerNotFound
         }
-        msg
-        |> http.parse_request(conn)
+
+        let res = {
+          use <- telemetry.span(
+            [telemetry.Mist, telemetry.ParseRequest],
+            dict.new(),
+          )
+          http.parse_request(msg, conn)
+        }
+
+        res
         |> result.map_error(fn(err) {
           case err {
             DiscardPacket -> process.Normal
···
         })
         |> result.then(fn(req) {
           case req {
-            http.Http1Request(req) ->
+            http.Http1Request(req) -> {
+              use <- telemetry.span(
+                [telemetry.Mist, telemetry.Http1Handler],
+                dict.new(),
+              )
               http_handler.call(req, handler, conn, sender)
               |> result.map(fn(new_state) {
                 Http1(state: new_state, self: self)
               })
-            http.Upgrade(data) ->
+            }
+            http.Upgrade(data) -> {
+              use <- telemetry.span(
+                [telemetry.Mist, telemetry.HttpUpgrade],
+                dict.new(),
+              )
               http2_handler.upgrade(data, conn, self)
               |> result.map(Http2)
+            }
           }
         })
       }

src/mist/internal/http.gleam

···
-// import birl
 import gleam/bit_array
 import gleam/bool
 import gleam/bytes_builder.{type BytesBuilder}
···
 import gleam/pair
 import gleam/result
 import gleam/string
-import gleam/uri
 import glisten.{type ClientIp, type Socket}
 import glisten/transport.{type Transport}
 import mist/internal/buffer.{type Buffer, Buffer}
 import mist/internal/clock
 import mist/internal/encoder
 import mist/internal/file
+import mist/internal/telemetry
 
 pub type ResponseData {
   Websocket(Selector(ProcessDown))
···
   transport: Transport,
   headers: Dict(String, String),
 ) -> Result(#(Dict(String, String), BitArray), DecodeError) {
-  case decode_packet(HttphBin, bs, []) {
+  let packet = {
+    use <- telemetry.span([telemetry.Mist, telemetry.DecodePacket], dict.new())
+    decode_packet(HttphBin, bs, [])
+  }
+  case packet {
     Ok(BinaryData(HttpHeader(_, _field, field, value), rest)) -> {
       let field = from_header(field)
       let assert Ok(value) = bit_array.to_string(value)
···
   buffer: Buffer,
   error: DecodeError,
 ) -> Result(BitArray, DecodeError) {
+  use <- telemetry.span([telemetry.Mist, telemetry.ReadData], dict.new())
   // TODO:  don't hard-code these, probably
   let to_read = int.min(buffer.remaining, 1_000_000)
   let timeout = 15_000
···
   Upgrade(BitArray)
 }
 
+import gleam/io
+
 /// Turns the TCP message into an HTTP request
 pub fn parse_request(
   bs: BitArray,
   conn: Connection,
 ) -> Result(ParsedRequest, DecodeError) {
-  case decode_packet(HttpBin, bs, []) {
+  use <- telemetry.span([telemetry.Mist, telemetry.ParseRequest2], dict.new())
+  let packet = {
+    use <- telemetry.span([telemetry.Mist, telemetry.DecodePacket], dict.new())
+    decode_packet(HttpBin, bs, [])
+  }
+  case packet {
     Ok(BinaryData(HttpRequest(http_method, AbsPath(path), _version), rest)) -> {
-      use method <- result.then(
-        http_method
-        |> atom.from_dynamic
-        |> result.map(atom.to_string)
-        |> result.or(dynamic.string(http_method))
-        |> result.nil_error
-        |> result.then(http.parse_method)
-        |> result.replace_error(UnknownMethod),
-      )
-      use #(headers, rest) <- result.then(parse_headers(
-        rest,
-        conn.socket,
-        conn.transport,
-        dict.new(),
-      ))
+      use method <-
+        {
+          use <- telemetry.span(
+            [telemetry.Mist, telemetry.ParseMethod],
+            dict.new(),
+          )
+          result.then(
+            http_method
+              |> atom.from_dynamic
+              |> result.map(atom.to_string)
+              |> result.or(dynamic.string(http_method))
+              |> result.nil_error
+              |> result.then(http.parse_method)
+              |> result.replace_error(UnknownMethod),
+            _,
+          )
+        }
+      use #(headers, rest) <-
+        {
+          use <- telemetry.span(
+            [telemetry.Mist, telemetry.ParseHeaders],
+            dict.new(),
+          )
+          result.then(
+            parse_headers(rest, conn.socket, conn.transport, dict.new()),
+            _,
+          )
+        }
+      use <- telemetry.span([telemetry.Mist, telemetry.ParseRest], dict.new())
       use path <- result.then(
         path
         |> bit_array.to_string
         |> result.replace_error(InvalidPath),
       )
-      use parsed <- result.then(
-        uri.parse(path)
-        |> result.replace_error(InvalidPath),
-      )
-      let #(path, query) = #(parsed.path, parsed.query)
+      use #(path, query) <-
+        {
+          use <- telemetry.span(
+            [telemetry.Mist, telemetry.ParsePath],
+            dict.new(),
+          )
+          result.try(
+            get_path_and_query(path)
+              |> result.replace_error(InvalidPath),
+            _,
+          )
+        }
       let scheme = case conn.transport {
         transport.Ssl(..) -> http.Https
         transport.Tcp(..) -> http.Http
       }
-      use host_header <- result.then(
-        dict.get(headers, "host")
-        |> result.replace_error(NoHostHeader),
+      use host_header <- result.then({
+        use <- telemetry.span([telemetry.Mist, telemetry.ParseHost], dict.new())
+        use host_header <- result.then(
+          dict.get(headers, "host")
+          |> result.replace_error(NoHostHeader),
+        )
+        Ok(host_header)
+      })
+      let #(hostname, port) = {
+        use <- telemetry.span([telemetry.Mist, telemetry.ParsePort], dict.new())
+        let #(hostname, port) =
+          host_header
+          |> string.split_once(":")
+          |> result.unwrap(#(host_header, ""))
+        let port =
+          int.parse(port)
+          |> result.map_error(fn(_err) {
+            case scheme {
+              http.Https -> 443
+              http.Http -> 80
+            }
+          })
+          |> result.unwrap_both
+        #(hostname, port)
+      }
+      use <- telemetry.span(
+        [telemetry.Mist, telemetry.BuildRequest],
+        dict.new(),
       )
-      let #(hostname, port) =
-        host_header
-        |> string.split_once(":")
-        |> result.unwrap(#(host_header, ""))
-      let port =
-        int.parse(port)
-        |> result.map_error(fn(_err) {
-          case scheme {
-            http.Https -> 443
-            http.Http -> 80
-          }
-        })
-        |> result.unwrap_both
       let req =
-        request.new()
-        |> request.set_scheme(scheme)
-        |> request.set_host(hostname)
-        |> request.set_port(port)
-        |> request.set_body(Connection(..conn, body: Initial(rest)))
-        |> request.set_method(method)
-        |> request.set_path(path)
-      Ok(Http1Request(
-        request.Request(..req, query: query, headers: dict.to_list(headers)),
-      ))
+        request.Request(
+          body: Connection(..conn, body: Initial(rest)),
+          headers: dict.to_list(headers),
+          host: hostname,
+          method: method,
+          path: path,
+          port: option.Some(port),
+          query: option.from_result(query),
+          scheme: scheme,
+        )
+      Ok(Http1Request(req))
     }
     // "\r\nSM\r\n\r\n"
     Ok(Http2Upgrade(<<
···
 
 @external(erlang, "binary", "split")
 fn binary_split(source: BitArray, pattern: BitArray) -> List(BitArray)
+
+@external(erlang, "mist_ffi", "get_path_and_query")
+fn get_path_and_query(
+  str: String,
+) -> Result(#(String, Result(String, Nil)), #(value, term))

src/mist/internal/http/handler.gleam

···
   conn: Connection,
 ) -> Result(Nil, SocketReason) {
   let assert File(file_descriptor, offset, length) = body
-  resp
-  |> response.prepend_header("content-length", int.to_string(length - offset))
-  |> response.set_body(bytes_builder.new())
-  |> fn(r: response.Response(BytesBuilder)) {
-    encoder.response_builder(resp.status, r.headers)
-  }
-  |> transport.send(conn.transport, conn.socket, _)
-  |> result.then(fn(_) {
-    file.sendfile(
-      conn.transport,
-      file_descriptor,
-      conn.socket,
-      offset,
-      length,
-      [],
-    )
-    |> result.map_error(fn(err) {
-      logging.log(logging.Error, "Failed to send file: " <> string.inspect(err))
-      Badarg
+  let return =
+    resp
+    |> response.prepend_header("content-length", int.to_string(length - offset))
+    |> response.set_body(bytes_builder.new())
+    |> fn(r: response.Response(BytesBuilder)) {
+      encoder.response_builder(resp.status, r.headers)
+    }
+    |> transport.send(conn.transport, conn.socket, _)
+    |> result.then(fn(_) {
+      file.sendfile(
+        conn.transport,
+        file_descriptor,
+        conn.socket,
+        offset,
+        length,
+        [],
+      )
+      |> result.map_error(fn(err) {
+        logging.log(
+          logging.Error,
+          "Failed to send file: " <> string.inspect(err),
+        )
+        Badarg
+      })
     })
-  })
-  |> result.replace(Nil)
+    |> result.replace(Nil)
+
+  case file.close(file_descriptor) {
+    Ok(_nil) -> Nil
+    Error(reason) -> {
+      logging.log(
+        logging.Error,
+        "Failed to close file: " <> string.inspect(reason),
+      )
+    }
+  }
+
+  return
 }
 
 fn handle_bytes_builder_body(

src/mist/internal/telemetry.gleam

···
+import gleam/dict.{type Dict}
+import gleam/dynamic.{type Dynamic}
+import gleam/erlang/atom.{type Atom}
+import gleam/int
+import gleam/result
+import gleam/string
+import logging
+
+pub type Event {
+  Start
+  Stop
+
+  Mist
+
+  ParseRequest
+  ParseRequest2
+
+  DecodePacket
+  ConvertPath
+  ParseMethod
+  ParseHeaders
+  ParseRest
+  ParsePath
+  ParseTransport
+  ParseHost
+  ParsePort
+  BuildRequest
+  ReadData
+
+  Http1Handler
+  HttpUpgrade
+  Http2Handler
+}
+
+pub const events = [
+  [Mist, ParseRequest, Stop],
+  [Mist, ParseRequest2, Stop],
+  [Mist, Http1Handler, Stop],
+  [Mist, HttpUpgrade, Stop],
+  [Mist, Http2Handler, Stop],
+  [Mist, DecodePacket, Stop],
+  [Mist, ConvertPath, Stop],
+  [Mist, ParseMethod, Stop],
+  [Mist, ParseHeaders, Stop],
+  [Mist, ParseRest, Stop],
+  [Mist, ParsePath, Stop],
+  [Mist, ParseTransport, Stop],
+  [Mist, ParseHost, Stop],
+  [Mist, ParsePort, Stop],
+  [Mist, BuildRequest, Stop],
+  [Mist, ReadData, Stop],
+]
+
+type TimeUnit {
+  Native
+  Microsecond
+}
+
+@external(erlang, "erlang", "convert_time_unit")
+fn convert_time_unit(
+  time: Int,
+  from from_unit: TimeUnit,
+  to to_unit: TimeUnit,
+) -> Int
+
+pub fn log(
+  path: List(Event),
+  measurements: Dict(Atom, Dynamic),
+  _metadata: Dict(String, Dynamic),
+  _config: List(config),
+) -> Nil {
+  let duration_string =
+    dict.get(measurements, atom.create_from_string("duration"))
+    |> result.then(fn(val) { result.nil_error(dynamic.int(val)) })
+    |> result.map(convert_time_unit(_, Native, Microsecond))
+    |> result.map(fn(time) { " duration: " <> int.to_string(time) <> "μs, " })
+    |> result.unwrap("")
+
+  logging.log(logging.Debug, string.inspect(path) <> duration_string)
+  // <> " metadata: "
+  // <> string.inspect(metadata),
+}
+
+pub fn span(
+  path: List(Event),
+  metadata: Dict(String, Dynamic),
+  wrapping: fn() -> return,
+) -> return {
+  use <- do_span(path, metadata)
+  let res = wrapping()
+  #(res, dict.new())
+}
+
+@external(erlang, "telemetry", "span")
+fn do_span(
+  path: List(Event),
+  metadata: Dict(String, Dynamic),
+  wrapping: fn() -> #(return, Dict(String, Dynamic)),
+) -> return
+
+pub fn attach_many(
+  id: String,
+  path: List(List(Event)),
+  handler: fn(
+    List(Event),
+    Dict(Atom, Dynamic),
+    Dict(String, Dynamic),
+    List(config),
+  ) ->
+    Nil,
+) -> Nil {
+  do_attach_many(id, path, handler, Nil)
+}
+
+@external(erlang, "telemetry", "attach_many")
+fn do_attach_many(
+  id: String,
+  path: List(List(Event)),
+  handler: fn(
+    List(Event),
+    Dict(Atom, Dynamic),
+    Dict(String, Dynamic),
+    List(config),
+  ) ->
+    Nil,
+  config: Nil,
+) -> Nil
+
+@external(erlang, "telemetry", "attach")
+pub fn attach(
+  id: String,
+  event: List(Event),
+  handler: fn(
+    List(Event),
+    Dict(Atom, Dynamic),
+    Dict(String, Dynamic),
+    List(config),
+  ) ->
+    Nil,
+  config: Nil,
+) -> Nil

src/mist_ffi.erl

···
 -module(mist_ffi).
 
 -export([binary_match/2, decode_packet/3, file_open/1, string_to_int/2, hpack_decode/2,
-         hpack_encode/2, hpack_new_max_table_size/2, ets_lookup_element/3]).
+         hpack_encode/2, hpack_new_max_table_size/2, ets_lookup_element/3, get_path_and_query/1,
+         file_close/1]).
 
 decode_packet(Type, Packet, Opts) ->
   case erlang:decode_packet(Type, Packet, Opts) of
···
       {error, unknown_file_error}
   end.
 
+file_close(File) ->
+  case file:close(File) of
+    ok ->
+      {ok, nil};
+    {error, enoent} ->
+      {error, no_entry};
+    {error, eacces} ->
+      {error, no_access};
+    {error, eisdir} ->
+      {error, is_dir};
+    _ ->
+      {error, unknown_file_error}
+  end.
+
 hpack_decode(Context, Bin) ->
   case hpack:decode(Bin, Context) of
     {ok, {Headers, NewContext}} ->
···
     error:badarg ->
       {error, nil}
   end.
+
+get_path_and_query(String) ->
+  case uri_string:parse(String) of
+    {error, Value, Term} ->
+      {error, {Value, Term}};
+    UriMap ->
+      Query =
+        case maps:find(query, UriMap) of
+          {ok, Value} ->
+            {ok, Value};
+          error ->
+            {error, nil}
+        end,
+      {ok, {maps:get(path, UriMap), Query}}
+  end.