1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

/*!
`tracing` Subscriber for structuring Stackdriver-compatible
[`LogEntry`](https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry)

While `Stackdriver` will eventually be a standalone Subscriber,
it's best used in its current form as an event formatter for the existing `Json` Subscriber in `tracing_subscriber`,
e.g.:

```
use tracing_subscriber::fmt::Subscriber;

fn main() {
    let subscriber = Subscriber::builder()
        .json()
        .event_format(Stackdriver::default())
        .finish();

    tracing::subscriber::set_global_default(subscriber).expect("Could not set up global logger");
}
```
*/
#![deny(missing_docs)]
use serde::ser::{SerializeMap, Serializer};
use serde_json::{self, json, Value};
use std::{
    fmt::{Formatter, Write},
    io,
};
use tracing::{Event, Subscriber};
use tracing_serde::{AsSerde, SerdeMapVisitor};
use tracing_subscriber::{
    fmt::{
        time::{ChronoUtc, FormatTime},
        FmtContext, FormatEvent, FormatFields, FormattedFields,
    },
    registry::LookupSpan,
};

/// A tracing adapater for stackdriver
pub struct Stackdriver {
    time: ChronoUtc,
}

impl Default for Stackdriver {
    fn default() -> Self {
        Self {
            time: ChronoUtc::rfc3339(),
        }
    }
}

impl<S, N> FormatEvent<S, N> for Stackdriver
where
    S: Subscriber + for<'a> LookupSpan<'a>,
    N: for<'a> FormatFields<'a> + 'static,
{
    fn format_event(
        &self,
        context: &FmtContext<S, N>,
        writer: &mut dyn Write,
        event: &Event,
    ) -> std::fmt::Result {
        let meta = event.metadata();
        let mut time_buffer = String::new();
        self.time.format_time(&mut time_buffer)?;

        // current ChronoUtc implementation has an extra space at the end of the timestamp
        let time = time_buffer.trim_end();

        let mut visit = || {
            let mut serializer = serde_json::Serializer::new(WriteAdaptor::new(writer));

            let mut serializer = serializer.serialize_map(None)?;

            serializer.serialize_entry("time", &time)?;
            serializer.serialize_entry("severity", &meta.level().as_serde())?;
            serializer.serialize_entry("target", &meta.target())?;

            context.visit_spans(|span| {
                let extensions = span.extensions();
                let data = extensions
                    .get::<FormattedFields<N>>()
                    .expect("Unable to find FormattedFields in extensions; this is a bug");

                // TODO: submit PR to fix this in tracing library
                let mut fields: Value = serde_json::from_str(&data)?;

                fields["name"] = json!(span.metadata().name());

                serializer.serialize_entry("span", &fields)
            })?;

            // TODO: enable deeper structuring of keys and values
            // https://github.com/tokio-rs/tracing/issues/663
            let mut visitor = SerdeMapVisitor::new(serializer);

            event.record(&mut visitor);

            visitor.finish()
        };

        visit().map_err(|_| std::fmt::Error)?;

        writeln!(writer)
    }
}

/// Utility newtype for converting between fmt::Write and io::Write
struct WriteAdaptor<'a> {
    fmt_write: &'a mut dyn Write,
}

impl<'a> WriteAdaptor<'a> {
    fn new(fmt_write: &'a mut dyn Write) -> Self {
        Self { fmt_write }
    }
}

impl<'a> io::Write for WriteAdaptor<'a> {
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        let s =
            std::str::from_utf8(buf).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;

        self.fmt_write
            .write_str(&s)
            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;

        Ok(s.as_bytes().len())
    }

    fn flush(&mut self) -> io::Result<()> {
        Ok(())
    }
}

impl<'a> std::fmt::Debug for WriteAdaptor<'a> {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
        formatter.pad("WriteAdaptor { .. }")
    }
}