From 41a9c374ac8ed2232c58fb474bd7b4725cadfeec Mon Sep 17 00:00:00 2001 From: David Dios Date: Sat, 6 Jul 2024 12:55:59 +0100 Subject: [PATCH] adding some more docs --- .gitignore | 3 ++ README.md | 32 ++++++------- gleam.toml | 6 +++ src/buckets.gleam | 9 ++-- src/ffi_buckets.erl | 2 +- src/ffi_counter.erl | 8 ++-- src/ffi_gauge.erl | 8 ++-- src/ffi_histogram.erl | 8 ++-- src/{ => internal}/never.gleam | 0 src/{ => internal}/prometheus_error.gleam | 2 +- src/metrics/counter.gleam | 48 +++++++++++++++---- src/metrics/gauge.gleam | 41 +++++++++++++--- src/metrics/histogram.gleam | 40 +++++++++++++--- src/print.gleam | 5 -- src/registry.gleam | 13 ++++- test/metrics/counter_test.gleam | 28 +++++------ test/metrics/gauge_test.gleam | 12 ++--- test/metrics/histogram_test.gleam | 16 +++---- .../{print_test.gleam => registry_test.gleam} | 25 +++++----- 19 files changed, 203 insertions(+), 103 deletions(-) rename src/{ => internal}/never.gleam (100%) rename src/{ => internal}/prometheus_error.gleam (91%) delete mode 100644 src/print.gleam rename test/{print_test.gleam => registry_test.gleam} (83%) diff --git a/.gitignore b/.gitignore index 599be4e..683ea6d 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,7 @@ *.beam *.ez +.history /build erl_crash.dump +todo.md +test/docs_test.gleam diff --git a/README.md b/README.md index 8dec5a0..46a0cf3 100644 --- a/README.md +++ b/README.md @@ -19,16 +19,16 @@ gleam add promgleam [(Source)](https://prometheus.io/docs/concepts/metric_types/#counter) ```gleam -import promgleam/metrics/counter.{new_counter, inc_counter} +import promgleam/metrics/counter.{create_counter, increment_counter} -new_counter( +create_counter( registry: "default", name: "http_requests_total", help: "Total number of HTTP requests", labels: [ "method", "route", "status" ], ) -inc_counter( +increment_counter( registry: "default", name: "http_requests_total", labels: [ "GET", "/", "200" ], @@ -43,19 +43,19 @@ Gauges are typically used for measured values like temperatures or current memor [(Source)](https://prometheus.io/docs/concepts/metric_types/#gauge) ```gleam -import promgleam/metrics/gauge.{new_gauge, set_gauge} +import promgleam/metrics/gauge.{create_gauge, set_gauge} -new_gauge( +create_gauge( registry: "default", name: "cache_size", help: "Number of items in the cache", labels: [ "cache_name" ], ) -inc_counter( +set_gauge( registry: "default", name: "cache_size", - labels: [ "users" ], + labels: [ "image_cache" ], value: 123, ) ``` @@ -66,14 +66,14 @@ inc_counter( [(Source)](https://prometheus.io/docs/concepts/metric_types/#histogram) ```gleam -import promgleam/metrics/histogram.{new_histogram, observe_histogram} +import promgleam/metrics/histogram.{create_histogram, observe_histogram} -new_histogram( +create_histogram( registry: "default", name: "http_request_duration_seconds", help: "Duration of HTTP requests in seconds", labels: [ "method", "route", "status" ], - buckets: [ 0.1, 0.25, 0.5, 1.0, 1.5 ] + buckets: [ 0.1, 0.25, 0.5, 1.0, 1.5 ], ) observe_histogram( @@ -91,17 +91,17 @@ This library provides utility functions to create `buckets` for a Histogram: ```gleam import promgleam/buckets.{exponential, linear} -exponential(start: 1.0, factor: 2, count: 5) // [1.0, 2.0, 4.0, 8.0, 10.0] -linear(start: 1.0, step: 3.0, count: 4) // [1.0, 4.0, 7.0, 10.0] +exponential(start: 1.0, factor: 2, count: 5) // Ok([1.0, 2.0, 4.0, 8.0, 10.0]) +linear(start: 1.0, step: 3.0, count: 4) // Ok([1.0, 4.0, 7.0, 10.0]) ``` -### Printing the content of a metric registry +### Printing the contents of a metric registry This can be done by using one of the `print_as` functions: -- `print_as_text` - Returns a `String` using the [Prometheus text-based format](https://github.com/prometheus/docs/blob/main/content/docs/instrumenting/exposition_formats.md#text-format-example) -- `print_as_prometheus` - Returns a `BitArray` using the [Prometheus Protobuf format](https://github.com/prometheus/docs/blob/main/content/docs/instrumenting/exposition_formats.md#protobuf-format) +- `print_as_text` - Serialises the registry using the [Prometheus text-based format](https://github.com/prometheus/docs/blob/main/content/docs/instrumenting/exposition_formats.md#text-format-example) into a `String` +- `print_as_prometheus` - Serialises the registry using the [Prometheus Protobuf format](https://github.com/prometheus/docs/blob/main/content/docs/instrumenting/exposition_formats.md#protobuf-format) into a `BitArray` ```gleam -import promgleam/print.{print_as_text, print_as_protobuf} +import promgleam/registry.{print_as_text, print_as_protobuf} print_as_text(registry_name: "default") print_as_protobuf(registry_name: "default") diff --git a/gleam.toml b/gleam.toml index 574dda2..4eef788 100644 --- a/gleam.toml +++ b/gleam.toml @@ -4,6 +4,12 @@ description = "A Prometheus client library for Gleam" licences = ["Apache-2.0"] repository = { type = "github", user = "dios-david", repo = "promgleam" } target = "erlang" +internal_modules = [ + "internal", + "internal/*", + "promgleam/internal", + "promgleam/internal/*" +] [dependencies] gleam_erlang = ">= 0.25.0 and < 1.0.0" diff --git a/src/buckets.gleam b/src/buckets.gleam index 4f17f4f..a610941 100644 --- a/src/buckets.gleam +++ b/src/buckets.gleam @@ -1,5 +1,7 @@ +//// Utility functions to generate buckets for Histogram metrics. + import gleam/string.{from_utf_codepoints} -import prometheus_error.{type PrometheusError, InvalidValue} +import internal/prometheus_error.{type PrometheusError, InvalidValue} pub type Buckets = List(Float) @@ -41,9 +43,8 @@ fn ffi_linear( count: Int, ) -> Result(Buckets, PrometheusError) -/// Creates `Count' buckets, each `Width' wide, where the lowest -/// bucket has an upper bound of `Start'. The returned list is meant to be -/// used for the `buckets' key of histogram constructors options. +/// Creates `count` buckets, each `step` wide, where the lowest bucket has an upper bound of +/// `start`. /// /// # Examples /// diff --git a/src/ffi_buckets.erl b/src/ffi_buckets.erl index e133a05..f777d89 100644 --- a/src/ffi_buckets.erl +++ b/src/ffi_buckets.erl @@ -1,6 +1,6 @@ -module(ffi_buckets). --import(lists,[droplast/1]). +-import(lists, [droplast/1]). -export([ exponential/3, diff --git a/src/ffi_counter.erl b/src/ffi_counter.erl index 29f3126..fce6b19 100644 --- a/src/ffi_counter.erl +++ b/src/ffi_counter.erl @@ -1,11 +1,11 @@ -module(ffi_counter). -export([ - counter_new/4, - counter_inc/4 + create_counter/4, + increment_counter/4 ]). -counter_new(Registry, Name, Help, Labels) -> +create_counter(Registry, Name, Help, Labels) -> try prometheus_counter:new([ { registry, Registry }, { name, Name }, @@ -18,7 +18,7 @@ counter_new(Registry, Name, Help, Labels) -> _:_ -> { error, unknown_error } end. -counter_inc(Registry, Name, LabelValues, Value) -> +increment_counter(Registry, Name, LabelValues, Value) -> try prometheus_counter:inc(Registry, Name, LabelValues, Value) of _ -> { ok, nil } catch diff --git a/src/ffi_gauge.erl b/src/ffi_gauge.erl index d15295e..ef19aeb 100644 --- a/src/ffi_gauge.erl +++ b/src/ffi_gauge.erl @@ -1,11 +1,11 @@ -module(ffi_gauge). -export([ - gauge_new/4, - gauge_set/4 + create_gauge/4, + set_gauge/4 ]). -gauge_new(Registry, Name, Help, Labels) -> +create_gauge(Registry, Name, Help, Labels) -> try prometheus_gauge:new([ { registry, Registry }, { name, Name }, @@ -18,7 +18,7 @@ gauge_new(Registry, Name, Help, Labels) -> _:_ -> { error, unknown_error } end. -gauge_set(Registry, Name, LabelValues, Value) -> +set_gauge(Registry, Name, LabelValues, Value) -> try prometheus_gauge:set(Registry, Name, LabelValues, Value) of _ -> { ok, nil } catch diff --git a/src/ffi_histogram.erl b/src/ffi_histogram.erl index 978a92a..a82876b 100644 --- a/src/ffi_histogram.erl +++ b/src/ffi_histogram.erl @@ -1,11 +1,11 @@ -module(ffi_histogram). -export([ - histogram_new/5, - histogram_observe/4 + create_histogram/5, + observe_histogram/4 ]). -histogram_new(Registry, Name, Help, Labels, Buckets) -> +create_histogram(Registry, Name, Help, Labels, Buckets) -> try prometheus_histogram:new([ { registry, Registry }, { name, Name }, @@ -19,7 +19,7 @@ histogram_new(Registry, Name, Help, Labels, Buckets) -> _:_ -> { error, unknown_error } end. -histogram_observe(Registry, Name, LabelValues, Value) -> +observe_histogram(Registry, Name, LabelValues, Value) -> try prometheus_histogram:observe(Registry, Name, LabelValues, Value) of _ -> { ok, nil } catch diff --git a/src/never.gleam b/src/internal/never.gleam similarity index 100% rename from src/never.gleam rename to src/internal/never.gleam diff --git a/src/prometheus_error.gleam b/src/internal/prometheus_error.gleam similarity index 91% rename from src/prometheus_error.gleam rename to src/internal/prometheus_error.gleam index ce75a38..cf2495c 100644 --- a/src/prometheus_error.gleam +++ b/src/internal/prometheus_error.gleam @@ -1,4 +1,4 @@ -import never.{type Never} +import internal/never.{type Never} pub type PrometheusError { InvalidBuckets(buckets: List(Float), reason: List(UtfCodepoint)) diff --git a/src/metrics/counter.gleam b/src/metrics/counter.gleam index 6563f54..40b6329 100644 --- a/src/metrics/counter.gleam +++ b/src/metrics/counter.gleam @@ -1,23 +1,42 @@ +//// A counter is a cumulative metric that represents a single monotonically increasing counter whose +//// value can only increase or be reset to zero on restart. For example, you can use a counter to +//// represent the number of requests served, tasks completed, or errors. +//// +//// Do not use a counter to expose a value that can decrease. For example, do not use a counter for +//// the number of currently running processes; instead use a gauge. + import gleam/int.{to_string} -import prometheus_error.{ +import internal/prometheus_error.{ type PrometheusError, InvalidMetricArity, MfAlreadyExists, UnknownMetric, } -@external(erlang, "ffi_counter", "counter_new") -fn ffi_new_counter( +@external(erlang, "ffi_counter", "create_counter") +fn ffi_create_counter( registry: String, name: String, help: String, labels: List(String), ) -> Result(Nil, PrometheusError) -pub fn new_counter( +/// Creates a new Counter metric. +/// +/// # Examples +/// +/// ```gleam +/// create_counter( +/// registry: "default", +/// name: "http_requests_total", +/// help: "Total number of HTTP requests", +/// labels: [ "method", "route", "status" ], +/// ) +/// ``` +pub fn create_counter( registry registry: String, name name: String, help help: String, labels labels: List(String), ) -> Result(Nil, String) { - let result = ffi_new_counter(registry, name, help, labels) + let result = ffi_create_counter(registry, name, help, labels) case result { Ok(_) -> Ok(Nil) @@ -26,21 +45,32 @@ pub fn new_counter( } } -@external(erlang, "ffi_counter", "counter_inc") -fn ffi_inc_counter( +@external(erlang, "ffi_counter", "increment_counter") +fn ffi_increment_counter( registry: String, name: String, labels: List(String), value: Int, ) -> Result(Nil, PrometheusError) -pub fn inc_counter( +/// Increments the Counter with the given value. +/// +/// # Examples +/// ```gleam +/// increment_counter( +/// registry: "default", +/// name: "http_requests_total", +/// labels: [ "GET", "/", "200" ], +/// value: 1, +/// ) +/// ``` +pub fn increment_counter( registry registry: String, name name: String, labels labels: List(String), value value: Int, ) -> Result(Nil, String) { - let result = ffi_inc_counter(registry, name, labels, value) + let result = ffi_increment_counter(registry, name, labels, value) case result { Ok(_) -> Ok(Nil) diff --git a/src/metrics/gauge.gleam b/src/metrics/gauge.gleam index 689a1fd..b85fd75 100644 --- a/src/metrics/gauge.gleam +++ b/src/metrics/gauge.gleam @@ -1,23 +1,41 @@ +//// A gauge is a metric that represents a single numerical value that can arbitrarily go +//// up and down. +//// +//// Gauges are typically used for measured values like temperatures or current memory usage, but +//// also "counts" that can go up and down, like the number of concurrent requests. + import gleam/int.{to_string} -import prometheus_error.{ +import internal/prometheus_error.{ type PrometheusError, InvalidMetricArity, MfAlreadyExists, UnknownMetric, } -@external(erlang, "ffi_gauge", "gauge_new") -fn ffi_new_gauge( +@external(erlang, "ffi_gauge", "create_gauge") +fn ffi_create_gauge( registry: String, name: String, help: String, labels labels: List(String), ) -> Result(Nil, PrometheusError) -pub fn new_gauge( +/// Creates a new Gauge metric. +/// +/// # Examples +/// +/// ```gleam +/// create_gauge( +/// registry: "default", +/// name: "cache_size", +/// help: "Number of items in the cache", +/// labels: [ "cache_name" ], +/// ) +/// ``` +pub fn create_gauge( registry registry: String, name name: String, help help: String, labels labels: List(String), ) -> Result(Nil, String) { - let result = ffi_new_gauge(registry, name, help, labels) + let result = ffi_create_gauge(registry, name, help, labels) case result { Ok(_) -> Ok(Nil) @@ -26,7 +44,7 @@ pub fn new_gauge( } } -@external(erlang, "ffi_gauge", "gauge_set") +@external(erlang, "ffi_gauge", "set_gauge") fn ffi_set_gauge( registry: String, name: String, @@ -34,6 +52,17 @@ fn ffi_set_gauge( value: Int, ) -> Result(Nil, PrometheusError) +/// Sets the value of the Gauge. +/// +/// # Examples +/// ```gleam +/// set_gauge( +/// registry: "default", +/// name: "cache_size", +/// labels: [ "image_cache" ], +/// value: 123, +/// ) +/// ``` pub fn set_gauge( registry registry: String, name name: String, diff --git a/src/metrics/histogram.gleam b/src/metrics/histogram.gleam index 11e284e..24fbb23 100644 --- a/src/metrics/histogram.gleam +++ b/src/metrics/histogram.gleam @@ -1,13 +1,16 @@ +//// A histogram samples observations (usually things like request durations or response sizes) +//// and counts them in configurable buckets. It also provides a sum of all observed values. + import buckets.{type Buckets} import gleam/int.{to_string} import gleam/string.{from_utf_codepoints} -import prometheus_error.{ +import internal/prometheus_error.{ type PrometheusError, InvalidBuckets, InvalidMetricArity, MfAlreadyExists, NoBuckets, UnknownMetric, } -@external(erlang, "ffi_histogram", "histogram_new") -fn ffi_new_histogram( +@external(erlang, "ffi_histogram", "create_histogram") +fn ffi_create_histogram( registry: String, name: String, help: String, @@ -15,14 +18,27 @@ fn ffi_new_histogram( buckets: Buckets, ) -> Result(Nil, PrometheusError) -pub fn new_histogram( +/// Creates a new Histogram metric. +/// +/// # Examples +/// +/// ```gleam +/// create_histogram( +/// registry: "default", +/// name: "http_request_duration_seconds", +/// help: "Duration of HTTP requests in seconds", +/// labels: [ "method", "route", "status" ], +/// buckets: [ 0.1, 0.25, 0.5, 1.0, 1.5 ], +/// ) +/// ``` +pub fn create_histogram( registry registry: String, name name: String, help help: String, labels labels: List(String), buckets buckets: Buckets, ) -> Result(Nil, String) { - let result = ffi_new_histogram(registry, name, help, labels, buckets) + let result = ffi_create_histogram(registry, name, help, labels, buckets) case result { Ok(_) -> Ok(Nil) @@ -34,7 +50,7 @@ pub fn new_histogram( } } -@external(erlang, "ffi_histogram", "histogram_observe") +@external(erlang, "ffi_histogram", "observe_histogram") fn ffi_observe_histogram( registry: String, name: String, @@ -42,6 +58,18 @@ fn ffi_observe_histogram( value: Float, ) -> Result(Nil, PrometheusError) +/// Observes a value in the Histogram. +/// +/// # Examples +/// +/// ```gleam +/// observe_histogram( +/// registry: "default", +/// name: "http_request_duration_seconds", +/// labels: [ "GET", "/", "200" ], +/// value: 0.23, +/// ) +/// ``` pub fn observe_histogram( registry registry: String, name name: String, diff --git a/src/print.gleam b/src/print.gleam deleted file mode 100644 index 1c74b9e..0000000 --- a/src/print.gleam +++ /dev/null @@ -1,5 +0,0 @@ -@external(erlang, "prometheus_text_format", "format") -pub fn print_as_text(registry_name registry_name: String) -> String - -@external(erlang, "prometheus_protobuf_format", "format") -pub fn print_as_protobuf(registry_name registry_name: String) -> BitArray diff --git a/src/registry.gleam b/src/registry.gleam index d831611..0f92a8c 100644 --- a/src/registry.gleam +++ b/src/registry.gleam @@ -1,4 +1,13 @@ -import never.{type Never} +//// Functions to interact with a metric registry. +/// Serialises the registry using the [Prometheus text-based format](https://github.com/prometheus/docs/blob/main/content/docs/instrumenting/exposition_formats.md#text-format-example). +@external(erlang, "prometheus_text_format", "format") +pub fn print_as_text(registry_name registry_name: String) -> String + +/// Serialises the registry using the [Prometheus Protobuf format](https://github.com/prometheus/docs/blob/main/content/docs/instrumenting/exposition_formats.md#protobuf-format). +@external(erlang, "prometheus_protobuf_format", "format") +pub fn print_as_protobuf(registry_name registry_name: String) -> BitArray + +/// Removes all the previously registered metrics from a registry. @external(erlang, "prometheus_registry", "clear") -pub fn clear_registry(name: String) -> Never +pub fn clear_registry(name: String) -> Nil diff --git a/test/metrics/counter_test.gleam b/test/metrics/counter_test.gleam index 97bb767..9bf3798 100644 --- a/test/metrics/counter_test.gleam +++ b/test/metrics/counter_test.gleam @@ -1,10 +1,10 @@ -import metrics/counter.{inc_counter, new_counter} +import metrics/counter.{create_counter, increment_counter} const registry_name = "counter_test_registry" -pub fn new_counter_test() { +pub fn create_counter_test() { let assert Ok(_) = - new_counter( + create_counter( registry: registry_name, name: "test", help: "test counter", @@ -12,7 +12,7 @@ pub fn new_counter_test() { ) let assert Error("Metric already exists") = - new_counter( + create_counter( registry: registry_name, name: "test", help: "test counter", @@ -20,21 +20,21 @@ pub fn new_counter_test() { ) } -pub fn counter_inc_test() { +pub fn counter_increment_test() { let assert Ok(_) = - new_counter( + create_counter( registry: registry_name, name: "ok", help: "basic counter", labels: [], ) let assert Ok(_) = - inc_counter(registry: registry_name, name: "ok", labels: [], value: 1) + increment_counter(registry: registry_name, name: "ok", labels: [], value: 1) } -pub fn counter_inc_non_existing_counter_test() { +pub fn counter_increment_non_existing_counter_test() { let assert Error("Unknown metric: non_existing_counter") = - inc_counter( + increment_counter( registry: registry_name, name: "non_existing_counter", labels: [], @@ -42,16 +42,16 @@ pub fn counter_inc_non_existing_counter_test() { ) } -pub fn counter_inc_with_labels() { +pub fn counter_increment_with_labels() { let assert Ok(_) = - new_counter( + create_counter( registry: registry_name, name: "with_labels", help: "metric with labels", labels: ["wibble", "wobble"], ) let assert Ok(_) = - inc_counter( + increment_counter( registry: registry_name, name: "with_labels", labels: ["A", "B"], @@ -61,7 +61,7 @@ pub fn counter_inc_with_labels() { let assert Error( "Invalid metric arity (labels mismatch): given 0, expected 2", ) = - inc_counter( + increment_counter( registry: registry_name, name: "with_labels", labels: [], @@ -71,7 +71,7 @@ pub fn counter_inc_with_labels() { let assert Error( "Invalid metric arity (labels mismatch): given 1, expected 2", ) = - inc_counter( + increment_counter( registry: registry_name, name: "with_labels", labels: ["A"], diff --git a/test/metrics/gauge_test.gleam b/test/metrics/gauge_test.gleam index 5fd8eb3..2031f0f 100644 --- a/test/metrics/gauge_test.gleam +++ b/test/metrics/gauge_test.gleam @@ -1,10 +1,10 @@ -import metrics/gauge.{new_gauge, set_gauge} +import metrics/gauge.{create_gauge, set_gauge} const registry_name = "gauge_test_registry" -pub fn new_gauge_test() { +pub fn create_gauge_test() { let assert Ok(_) = - new_gauge( + create_gauge( registry: registry_name, name: "test", help: "test gauge", @@ -12,7 +12,7 @@ pub fn new_gauge_test() { ) let assert Error("Metric already exists") = - new_gauge( + create_gauge( registry: registry_name, name: "test", help: "test gauge", @@ -22,7 +22,7 @@ pub fn new_gauge_test() { pub fn gauge_set_test() { let assert Ok(_) = - new_gauge( + create_gauge( registry: registry_name, name: "ok", help: "basic gauge", @@ -44,7 +44,7 @@ pub fn gauge_set_non_existing_gauge_test() { pub fn gauge_set_with_labels() { let assert Ok(_) = - new_gauge( + create_gauge( registry: registry_name, name: "with_labels", help: "metric with labels", diff --git a/test/metrics/histogram_test.gleam b/test/metrics/histogram_test.gleam index 2a26399..dd4f86f 100644 --- a/test/metrics/histogram_test.gleam +++ b/test/metrics/histogram_test.gleam @@ -1,10 +1,10 @@ -import metrics/histogram.{new_histogram, observe_histogram} +import metrics/histogram.{create_histogram, observe_histogram} const registry_name = "histogram_test_registry" -pub fn new_histogram_test() { +pub fn create_histogram_test() { let assert Ok(_) = - new_histogram( + create_histogram( registry: registry_name, name: "test", help: "test histogram", @@ -13,7 +13,7 @@ pub fn new_histogram_test() { ) let assert Error("Metric already exists") = - new_histogram( + create_histogram( registry: registry_name, name: "test", help: "test histogram", @@ -22,7 +22,7 @@ pub fn new_histogram_test() { ) let assert Error("No buckets were provided") = - new_histogram( + create_histogram( registry: registry_name, name: "test2", help: "test histogram", @@ -31,7 +31,7 @@ pub fn new_histogram_test() { ) let assert Error("Invalid buckets: buckets not sorted") = - new_histogram( + create_histogram( registry: registry_name, name: "test3", help: "test histogram", @@ -42,7 +42,7 @@ pub fn new_histogram_test() { pub fn histogram_observe_test() { let assert Ok(_) = - new_histogram( + create_histogram( registry: registry_name, name: "ok", help: "basic histogram", @@ -70,7 +70,7 @@ pub fn histogram_observe_non_existing_histogram_test() { pub fn histogram_observe_with_labels() { let assert Ok(_) = - new_histogram( + create_histogram( registry: registry_name, name: "with_labels", help: "metric with labels", diff --git a/test/print_test.gleam b/test/registry_test.gleam similarity index 83% rename from test/print_test.gleam rename to test/registry_test.gleam index 48785c4..a96b5e4 100644 --- a/test/print_test.gleam +++ b/test/registry_test.gleam @@ -1,11 +1,10 @@ import birdie.{snap} import buckets.{exponential} -import metrics/counter.{inc_counter, new_counter} -import metrics/gauge.{new_gauge, set_gauge} -import metrics/histogram.{new_histogram, observe_histogram} +import metrics/counter.{create_counter, increment_counter} +import metrics/gauge.{create_gauge, set_gauge} +import metrics/histogram.{create_histogram, observe_histogram} import pprint.{format} -import print.{print_as_protobuf, print_as_text} -import registry.{clear_registry} +import registry.{clear_registry, print_as_protobuf, print_as_text} const counter_name = "my_counter" @@ -19,21 +18,21 @@ pub fn print_as_text_test() { clear_registry(registry_name) let assert Ok(_) = - new_counter( + create_counter( registry: registry_name, name: counter_name, help: "my counter help text", labels: ["wibble", "wobble"], ) let assert Ok(_) = - inc_counter( + increment_counter( registry: registry_name, name: counter_name, labels: ["A", "B"], value: 1, ) let assert Ok(_) = - inc_counter( + increment_counter( registry: registry_name, name: counter_name, labels: ["C", "D"], @@ -41,7 +40,7 @@ pub fn print_as_text_test() { ) let assert Ok(_) = - new_gauge( + create_gauge( registry: registry_name, name: gauge_name, help: "my gauge help text", @@ -58,7 +57,7 @@ pub fn print_as_text_test() { let assert Ok(buckets) = exponential(1.0, 2, 3) let assert Ok(_) = - new_histogram( + create_histogram( registry: registry_name, name: histogram_name, help: "my histogram help text", @@ -83,21 +82,21 @@ pub fn print_as_protobuf_test() { clear_registry(registry_name) let assert Ok(_) = - new_counter( + create_counter( registry: registry_name, name: counter_name, help: "metric with labels", labels: ["wibble", "wobble"], ) let assert Ok(_) = - inc_counter( + increment_counter( registry: registry_name, name: counter_name, labels: ["A", "B"], value: 1, ) let assert Ok(_) = - inc_counter( + increment_counter( registry: registry_name, name: counter_name, labels: ["C", "D"],