• Add implementation around setting up the TraceLogger and a custom filter to exclude routes from the Span. This way we will not log specific routes (eg, liveness, readiness).
• Add new example showing how to exclude specific routes.
• Add tests for the new code.
• Update codeowners file.

fixes: #2

We will need a way to extend the env_filter for the subscriber in a manner that allows someone using this crate to write their own filtering middleware. The issue is that the tracing-actix-web crate doesn't have a good way of excluding route logging like the standard actix-web middleware::Logger.

    let server = HttpServer::new({
        let stop_handle = stop_handle.clone();
        let telemerty_config = web::Data::new(telemetry_config);
        move || {
            App::new()
                .app_data(stop_handle.clone())
                .app_data(telemerty_config.clone())
                .service(hello)
                .wrap(
                    middleware::Logger::default()
                        .exclude("/health/liveness")
                        .exclude("/health/readiness"),
                )
                .service(liveness)
                .service(readiness)
        }
    })
    .bind(server_bind_address.clone())?
    .shutdown_timeout(5)
    .run();

Since we are using tracing-actix-web crate, we must use TracingLogger to set Spans in the application. A good example of how to do this would be do extend something that looks like this:

// Create a custom RootSpanBuilder
pub struct CustomLevelRootSpanBuilder;

impl RootSpanBuilder for CustomLevelRootSpanBuilder {
    fn on_request_start(request: &ServiceRequest) -> Span {
        // If the path matches our excluded routes, do not generate a span.
        match request.path() {
            "/health/liveness" | "/health/readiness" => {
                // This is the crucial part: returning a non-recording span
                // effectively "turns off" tracing for this request.
                Span::none()
            }
            _ => tracing_actix_web::root_span!(level = Level::INFO, request),
        }
    }

    fn on_request_end<B: MessageBody>(span: Span, outcome: &Result<ServiceResponse<B>, Error>) {
        DefaultRootSpanBuilder::on_request_end(span, outcome);
    }
}

Then just build out the custom middleware with let middleware = TracingLogger::<CustomLevelRootSpanBuilder>::new();. Not quite sure if that is all that would have to be done, but I believe it's a start of something that could work.