refactor: remove Prometheus related dependencies from actix instrumentation (#246)

Author: gruebel

deny.toml

@@ -1,7 +1,5 @@
 [graph]
-exclude=[
-    "protobuf" # opentelemetry-instrumentation-actix-web depends on prometheus should try to remove it
-]
+exclude=[]
 
 [licenses]
 allow = [

opentelemetry-instrumentation-actix-web/CHANGELOG.md

@@ -4,7 +4,31 @@
 
 ### Changed
 
+* Remove `opentelemetry-prometheus`, `opentelemetry_sdk`, `prometheus` and `tracing` dependencies
 * **Breaking** Rename crate to `opentelemetry-instrumentation-actix-web`
+* **Breaking** Remove `metrics-prometheus` feature and use `metric` feature instead
+* **Breaking** Remove Prometheus middleware `PrometheusMetricsHandler` and use OTLP exporter instead
+  ```rust
+  // Initialize OTLP exporter using HTTP binary protocol
+  let exporter = opentelemetry_otlp::MetricExporter::builder()
+      .with_http()
+      .with_protocol(Protocol::HttpBinary)
+      .with_endpoint("http://localhost:9090/api/v1/otlp/v1/metrics")
+      .build()?;
+
+  // set up your meter provider with your exporter(s)
+  let provider = SdkMeterProvider::builder()
+      .with_periodic_exporter(exporter)
+      .with_resource(
+          // recommended attributes
+          Resource::builder_empty()
+              .with_attribute(KeyValue::new("service.name", "my_app"))
+              .with_attribute(KeyValue::new("service.instance.id", Uuid::new_v4().to_string()))
+              .build(),
+      )
+      .build();
+  global::set_meter_provider(provider.clone());
+  ```
 
 ## [v0.22.0](https://github.com/OutThereLabs/actix-web-opentelemetry/compare/v0.22.0..v0.21.0)
 

opentelemetry-instrumentation-actix-web/Cargo.toml

@@ -6,20 +6,13 @@ homepage = "https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/ma
 repository = "https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/main/actix-web-opentelemetry"
 readme = "README.md"
 categories = ["api-bindings"]
-keywords = ["actix", "actix-web", "opentelemetry", "prometheus"]
+keywords = ["actix", "actix-web", "opentelemetry"]
 license = "Apache-2.0"
 edition = "2021"
 rust-version = "1.75.0"
 
 [features]
 metrics = ["opentelemetry/metrics"]
-metrics-prometheus = [
-  "metrics",
-  "opentelemetry-prometheus",
-  "prometheus",
-  "dep:opentelemetry_sdk",
-  "dep:tracing",
-]
 sync-middleware = []
 
 [dependencies]
@@ -36,22 +29,15 @@ futures-util = { version = "0.3", default-features = false, features = [
   "alloc",
 ] }
 opentelemetry = { workspace = true, features = ["trace"] }
-opentelemetry-prometheus = { version = "0.29", optional = true }
 opentelemetry-semantic-conventions = { workspace = true, features = [
   "semconv_experimental",
 ] }
-opentelemetry_sdk = { workspace = true, optional = true, features = [
-  "metrics",
-  "rt-tokio-current-thread",
-] }
-prometheus = { version = "0.13", default-features = false, optional = true }
 serde = "1.0"
-tracing = { version = "0.1.41", optional = true }
 
 [dev-dependencies]
 actix-web = { version = "4.0", features = ["macros"] }
 opentelemetry-instrumentation-actix-web = { path = ".", features = [
-  "metrics-prometheus",
+  "metrics",
   "sync-middleware",
   "awc",
 ] }
@@ -60,7 +46,6 @@ opentelemetry_sdk = { workspace = true, features = [
   "metrics",
   "rt-tokio-current-thread",
 ] }
-opentelemetry-otlp = { version = "0.29", features = ["grpc-tonic"] }
 opentelemetry-stdout = { workspace = true, features = ["trace", "metrics"] }
 
 [package.metadata.docs.rs]

opentelemetry-instrumentation-actix-web/README.md

@@ -52,5 +52,4 @@ $ firefox http://localhost:16686/
 
 - `awc` -- enable support for tracing the `awc` http client.
 - `metrics` -- enable support for opentelemetry metrics (only traces are enabled by default)
-- `metrics-prometheus` -- enable support for prometheus metrics (requires `metrics` feature)
 - `sync-middleware` -- enable tracing on actix-web middlewares that do synchronous work before returning a future. Adds a small amount of overhead to every request.

opentelemetry-instrumentation-actix-web/examples/client.rs

@@ -3,6 +3,7 @@ use opentelemetry_instrumentation_actix_web::ClientExt;
 use opentelemetry_sdk::propagation::TraceContextPropagator;
 use opentelemetry_sdk::trace::SdkTracerProvider;
 use opentelemetry_sdk::Resource;
+use opentelemetry_stdout::SpanExporter;
 use std::error::Error;
 use std::io;
 
@@ -34,11 +35,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
         .build();
 
     let tracer = SdkTracerProvider::builder()
-        .with_batch_exporter(
-            opentelemetry_otlp::SpanExporter::builder()
-                .with_tonic()
-                .build()?,
-        )
+        .with_batch_exporter(SpanExporter::default())
         .with_resource(service_name_resource)
         .build();
 

opentelemetry-instrumentation-actix-web/examples/server.rs

@@ -1,18 +1,16 @@
-use actix_web::{web, App, HttpRequest, HttpServer};
+use actix_web::{web, App, HttpResponse, HttpServer, Responder};
 use opentelemetry::{global, KeyValue};
-use opentelemetry_instrumentation_actix_web::{
-    PrometheusMetricsHandler, RequestMetrics, RequestTracing,
-};
-use opentelemetry_otlp::WithExportConfig;
+use opentelemetry_instrumentation_actix_web::{RequestMetrics, RequestTracing};
 use opentelemetry_sdk::{
     metrics::{Aggregation, Instrument, SdkMeterProvider, Stream},
     propagation::TraceContextPropagator,
     trace::SdkTracerProvider,
     Resource,
 };
+use opentelemetry_stdout::{MetricExporter, SpanExporter};
 
-async fn index(_req: HttpRequest, _path: actix_web::web::Path<String>) -> &'static str {
-    "Hello world!"
+async fn manual_hello() -> impl Responder {
+    HttpResponse::Ok().body("Hey there!")
 }
 
 #[actix_web::main]
@@ -25,27 +23,17 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .build();
 
     let tracer = SdkTracerProvider::builder()
-        .with_batch_exporter(
-            opentelemetry_otlp::SpanExporter::builder()
-                .with_tonic()
-                .with_endpoint("http://127.0.0.1:6565")
-                .build()?,
-        )
+        .with_simple_exporter(SpanExporter::default())
         .with_resource(service_name_resource)
         .build();
 
     global::set_tracer_provider(tracer.clone());
 
-    // Start a new prometheus metrics pipeline if --features metrics-prometheus is used
-    #[cfg(feature = "metrics-prometheus")]
-    let (metrics_handler, meter_provider) = {
-        let registry = prometheus::Registry::new();
-        let exporter = opentelemetry_prometheus::exporter()
-            .with_registry(registry.clone())
-            .build()?;
-
+    // Setup a OTLP metrics exporter if --features metrics is used
+    #[cfg(feature = "metrics")]
+    let meter_provider = {
         let provider = SdkMeterProvider::builder()
-            .with_reader(exporter)
+            .with_periodic_exporter(MetricExporter::default())
             .with_resource(
                 Resource::builder_empty()
                     .with_attribute(KeyValue::new("service.name", "my_app"))
@@ -67,19 +55,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             .build();
         global::set_meter_provider(provider.clone());
 
-        (PrometheusMetricsHandler::new(registry), provider)
+        provider
     };
 
     HttpServer::new(move || {
-        let app = App::new()
+        App::new()
             .wrap(RequestTracing::new())
             .wrap(RequestMetrics::default())
-            .service(web::resource("/users/{id}").to(index));
-
-        #[cfg(feature = "metrics-prometheus")]
-        let app = app.route("/metrics", web::get().to(metrics_handler.clone()));
-
-        app
+            .route("/hey", web::get().to(manual_hello))
     })
     .bind("127.0.0.1:8080")?
     .run()
@@ -88,7 +71,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Ensure all spans have been reported
     tracer.shutdown()?;
 
-    #[cfg(feature = "metrics-prometheus")]
+    #[cfg(feature = "metrics")]
     meter_provider.shutdown()?;
 
     Ok(())

opentelemetry-instrumentation-actix-web/src/lib.rs

@@ -8,7 +8,8 @@
 //!
 //! * Client requests can be traced by using the [`ClientExt::trace_request`] method.
 //!
-//! The `metrics` feature allows you to expose request metrics to [Prometheus].
+//! The `metrics` feature allows you to export request metrics to any OTLP supported
+//! backend like [Prometheus].
 //!
 //! * Metrics can be tracked using the [`RequestMetrics`] middleware.
 //!
@@ -59,9 +60,8 @@
 //!
 //! #[actix_web::main]
 //! async fn main() -> std::io::Result<()> {
-//!     // Install an OpenTelemetry trace pipeline.
-//!     // Swap for https://docs.rs/opentelemetry-jaeger or other compatible
-//!     // exporter to send trace information to your collector.
+//!     // Swap for `opentelemetry_otlp` or any other compatible
+//!     // exporter to send metrics to your collector.
 //!     let exporter = opentelemetry_stdout::SpanExporter::default();
 //!
 //!     // Configure your tracer provider with your exporter(s)
@@ -86,43 +86,55 @@
 //!
 //! ```no_run
 //! use actix_web::{dev, http, web, App, HttpRequest, HttpServer};
-//! use opentelemetry::global;
-//! # #[cfg(feature = "metrics-prometheus")]
-//! use opentelemetry_instrumentation_actix_web::{PrometheusMetricsHandler, RequestMetrics, RequestTracing};
-//! use opentelemetry_sdk::metrics::SdkMeterProvider;
+//! use opentelemetry::{global, KeyValue};
+//! # #[cfg(feature = "metrics")]
+//! use opentelemetry_instrumentation_actix_web::{RequestMetrics, RequestTracing};
+//! use opentelemetry_sdk::{metrics::SdkMeterProvider, Resource};
+//!
+//! async fn index() -> &'static str {
+//!     "Hello world!"
+//! }
 //!
-//! # #[cfg(feature = "metrics-prometheus")]
+//! # #[cfg(feature = "metrics")]
 //! #[actix_web::main]
 //! async fn main() -> Result<(), Box<dyn std::error::Error>> {
-//!     // Configure prometheus or your preferred metrics service
-//!     let registry = prometheus::Registry::new();
-//!     let exporter = opentelemetry_prometheus::exporter()
-//!         .with_registry(registry.clone())
-//!         .build()?;
+//!     // Swap for `opentelemetry_otlp` or any other compatible
+//!     // exporter to send metrics to your collector.
+//!     let exporter = opentelemetry_stdout::MetricExporter::default();
 //!
 //!     // set up your meter provider with your exporter(s)
 //!     let provider = SdkMeterProvider::builder()
-//!         .with_reader(exporter)
+//!         .with_periodic_exporter(exporter)
+//!         .with_resource(
+//!             Resource::builder_empty()
+//!                 .with_attribute(KeyValue::new("service.name", "my_app"))
+//!                 .build(),
+//!         )
 //!         .build();
-//!     global::set_meter_provider(provider);
+//!     global::set_meter_provider(provider.clone());
 //!
 //!     // Run actix server, metrics are now available at http://localhost:8080/metrics
 //!     HttpServer::new(move || {
 //!         App::new()
 //!             .wrap(RequestTracing::new())
 //!             .wrap(RequestMetrics::default())
-//!             .route("/metrics", web::get().to(PrometheusMetricsHandler::new(registry.clone())))
+//!             .service(web::resource("/").to(index))
 //!         })
 //!         .bind("localhost:8080")?
 //!         .run()
 //!         .await;
 //!
+//!     //Shutdown the meter provider. This will trigger an export of all metrics.
+//!     provider.shutdown()?;
+//!
 //!     Ok(())
 //! }
-//! # #[cfg(not(feature = "metrics-prometheus"))]
+//! # #[cfg(not(feature = "metrics"))]
 //! # fn main() {}
 //! ```
 //!
+//! For more information on how to configure Prometheus with [OTLP](https://prometheus.io/docs/guides/opentelemetry)
+//!
 //! ### Exporter configuration
 //!
 //! [`actix-web`] uses [`tokio`] as the underlying executor, so exporters should be
@@ -153,9 +165,6 @@ mod util;
 #[cfg_attr(docsrs, doc(cfg(feature = "awc")))]
 pub use client::{ClientExt, InstrumentedClientRequest};
 
-#[cfg(feature = "metrics-prometheus")]
-#[cfg_attr(docsrs, doc(cfg(feature = "metrics-prometheus")))]
-pub use middleware::metrics::prometheus::PrometheusMetricsHandler;
 #[cfg(feature = "metrics")]
 #[cfg_attr(docsrs, doc(cfg(feature = "metrics")))]
 pub use middleware::metrics::{RequestMetrics, RequestMetricsBuilder, RequestMetricsMiddleware};