tracing: Support disabling tracing entirely (#723)

When the proxy log level is set to `off`, the proxy now skips all
tracing initialization and disables the tracing admin endpoints. This
allows us to minimize the overhead of tracing in benchmarks and
performance-critical environments.

This has a noticeable impact on _memory_. In local tests, we see
`main` use around ~24MB with the log level set to `off`. With this
branch, memory comes down to ~16MB.

Author: olix0r

linkerd/tracing/src/lib.rs

@@ -32,8 +32,11 @@ type Formatter<F, E> = Layered<
 /// environment variable as the verbosity-level filter.
 pub fn init() -> Result<Handle, Error> {
     let log_level = env::var(ENV_LOG_LEVEL).unwrap_or(DEFAULT_LOG_LEVEL.to_string());
-    let log_format = env::var(ENV_LOG_FORMAT).unwrap_or(DEFAULT_LOG_FORMAT.to_string());
+    if let "OFF" = log_level.to_uppercase().trim() {
+        return Ok(Handle(Inner::Disabled));
+    }
 
+    let log_format = env::var(ENV_LOG_FORMAT).unwrap_or(DEFAULT_LOG_FORMAT.to_string());
     let (dispatch, handle) = with_filter_and_format(log_level, log_format);
 
     // Set up log compatibility.
@@ -92,17 +95,23 @@ pub fn with_filter_and_format(
 
     (
         dispatch,
-        Handle {
+        Handle(Inner::Enabled {
             level,
             tasks: tasks::Handle { tasks },
-        },
+        }),
     )
 }
 
 #[derive(Clone)]
-pub struct Handle {
-    level: level::Handle,
-    tasks: tasks::Handle,
+pub struct Handle(Inner);
+
+#[derive(Clone)]
+enum Inner {
+    Disabled,
+    Enabled {
+        level: level::Handle,
+        tasks: tasks::Handle,
+    },
 }
 
 // === impl Handle ===
@@ -114,14 +123,27 @@ impl Handle {
         &self,
         req: http::Request<hyper::Body>,
     ) -> Result<http::Response<hyper::Body>, Error> {
-        self.level.serve(req).await
+        match self.0 {
+            Inner::Enabled { ref level, .. } => level.serve(req).await,
+            Inner::Disabled => Ok(Self::not_found()),
+        }
     }
 
     /// Serve requests for task dumps.
     pub async fn serve_tasks(
         &self,
         req: http::Request<hyper::Body>,
     ) -> Result<http::Response<hyper::Body>, Error> {
-        self.tasks.serve(req)
+        match self.0 {
+            Inner::Enabled { ref tasks, .. } => tasks.serve(req),
+            Inner::Disabled => Ok(Self::not_found()),
+        }
+    }
+
+    fn not_found() -> http::Response<hyper::Body> {
+        http::Response::builder()
+            .status(http::StatusCode::NOT_FOUND)
+            .body(hyper::Body::empty())
+            .expect("Response must be valid")
     }
 }