forwarder: Add dump only option

Added a `--dump-only` option which disables forwarding of trace spans.
This essentially makes the forwarder a NOP but can be useful for testing
purposes.

Fixes: #2132.

Signed-off-by: James O. D. Hunt <james.o.hunt@intel.com>

src/trace-forwarder/src/handler.rs

@@ -32,13 +32,14 @@ pub async fn handle_connection<'a>(
     logger: Logger,
     mut conn: VsockStream,
     exporter: &'a mut dyn SpanExporter,
+    dump_only: bool,
 ) -> Result<()> {
     let logger = logger.new(o!("subsystem" => "handler",
             "connection" => format!("{:?}", conn)));
 
     debug!(logger, "handling connection");
 
-    handle_trace_data(logger.clone(), &mut conn, exporter)
+    handle_trace_data(logger.clone(), &mut conn, exporter, dump_only)
         .await
         .map_err(|e| mk_io_err(&format!("failed to handle data: {:}", e)))?;
 
@@ -56,6 +57,7 @@ async fn handle_trace_data<'a>(
     logger: Logger,
     reader: &'a mut dyn Read,
     exporter: &'a mut dyn SpanExporter,
+    dump_only: bool,
 ) -> Result<()> {
     loop {
         let mut header: [u8; HEADER_SIZE_BYTES as usize] = [0; HEADER_SIZE_BYTES as usize];
@@ -90,6 +92,9 @@ async fn handle_trace_data<'a>(
 
         debug!(logger, "deserialised payload");
 
+        if dump_only {
+            debug!(logger, "dump-only: {:?}", span_data);
+        } else {
             let mut batch = Vec::<SpanData>::new();
 
             batch.push(span_data);
@@ -103,6 +108,7 @@ async fn handle_trace_data<'a>(
 
             debug!(logger, "exported trace spans");
         }
+    }
 
     Ok(())
 }

src/trace-forwarder/src/main.rs

@@ -36,12 +36,13 @@ mod handler;
 mod server;
 mod tracer;
 
-fn announce(logger: &Logger, version: &str) {
+fn announce(logger: &Logger, version: &str, dump_only: bool) {
     let commit = env::var("VERSION_COMMIT").map_or(String::new(), |s| s);
 
     info!(logger, "announce";
     "commit-version" => commit.as_str(),
-    "version" =>  version);
+    "version" =>  version,
+    "dump-only" => dump_only);
 }
 
 fn make_examples_text(program_name: &str) -> String {
@@ -69,6 +70,11 @@ fn real_main() -> Result<()> {
         .about(ABOUT_TEXT)
         .long_about(DESCRIPTION_TEXT)
         .after_help(&*make_examples_text(name))
+        .arg(
+            Arg::with_name("dump-only")
+                .long("dump-only")
+                .help("Disable forwarding of spans and write to stdout (for testing)"),
+        )
         .arg(
             Arg::with_name("trace-name")
                 .long("trace-name")
@@ -182,7 +188,9 @@ fn real_main() -> Result<()> {
     let writer = io::stdout();
     let (logger, _logger_guard) = logging::create_logger(name, name, log_level, writer);
 
-    announce(&logger, version);
+    let dump_only = args.is_present("dump-only");
+
+    announce(&logger, version, dump_only);
 
     let trace_name: &str = args
         .value_of("trace-name")
@@ -205,6 +213,7 @@ fn real_main() -> Result<()> {
         jaeger_host,
         jaeger_port,
         trace_name,
+        dump_only,
     );
 
     let result = server.start();

src/trace-forwarder/src/server.rs

@@ -21,6 +21,7 @@ pub struct VsockTraceServer {
     pub jaeger_service_name: String,
 
     pub logger: Logger,
+    pub dump_only: bool,
 }
 
 impl VsockTraceServer {
@@ -31,16 +32,18 @@ impl VsockTraceServer {
         jaeger_host: &str,
         jaeger_port: u32,
         jaeger_service_name: &str,
+        dump_only: bool,
     ) -> Self {
         let logger = logger.new(o!("subsystem" => "server"));
 
         VsockTraceServer {
-            vsock_port: vsock_port,
+            vsock_port,
-            vsock_cid: vsock_cid,
+            vsock_cid,
             jaeger_host: jaeger_host.to_string(),
-            jaeger_port: jaeger_port,
+            jaeger_port,
             jaeger_service_name: jaeger_service_name.to_string(),
-            logger: logger,
+            logger,
+            dump_only,
         }
     }
 
@@ -71,7 +74,7 @@ impl VsockTraceServer {
 
                     let logger = self.logger.new(o!());
 
-                    let f = handler::handle_connection(logger, conn, &mut exporter);
+                    let f = handler::handle_connection(logger, conn, &mut exporter, self.dump_only);
 
                     block_on(f)?;
                 }