logforth_bridge_log/
lib.rs

1// Copyright 2024 FastLabs Developers
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15//! A bridge to forward logs from the `log` crate to `logforth`.
16
17#![cfg_attr(docsrs, feature(doc_cfg))]
18#![deny(missing_docs)]
19
20use std::ops::Deref;
21use std::sync::Arc;
22
23use log::Metadata;
24use log::Record;
25use logforth_core::Logger;
26use logforth_core::record::FilterCriteria;
27
28/// Adapter to use a `logforth` logger instance as a `log` crate logger.
29#[derive(Debug)]
30pub struct LogBridge {
31    logger: Arc<Logger>,
32}
33
34impl LogBridge {
35    /// Create a new `LogBridge` instance.
36    pub fn new(logger: impl Into<Arc<Logger>>) -> Self {
37        Self {
38            logger: logger.into(),
39        }
40    }
41}
42
43impl Deref for LogBridge {
44    type Target = Logger;
45
46    fn deref(&self) -> &Self::Target {
47        &self.logger
48    }
49}
50
51impl log::Log for LogBridge {
52    fn enabled(&self, metadata: &Metadata) -> bool {
53        forward_enabled(&self.logger, metadata)
54    }
55
56    fn log(&self, record: &Record) {
57        forward_log(&self.logger, record);
58    }
59
60    fn flush(&self) {
61        self.logger.flush();
62    }
63}
64
65fn forward_enabled(logger: &Logger, metadata: &Metadata) -> bool {
66    let criteria = FilterCriteria::builder()
67        .target(metadata.target())
68        .level(level_to_level(metadata.level()))
69        .build();
70
71    Logger::enabled(logger, &criteria)
72}
73
74fn forward_log(logger: &Logger, record: &Record) {
75    if !forward_enabled(logger, record.metadata()) {
76        return;
77    }
78
79    // basic fields
80    let mut builder = logforth_core::record::Record::builder()
81        .level(level_to_level(record.level()))
82        .target(record.target())
83        .line(record.line());
84
85    // optional static fields
86    builder = if let Some(module_path) = record.module_path_static() {
87        builder.module_path_static(module_path)
88    } else {
89        builder.module_path(record.module_path())
90    };
91    builder = if let Some(file) = record.file_static() {
92        builder.file_static(file)
93    } else {
94        builder.file(record.file())
95    };
96
97    // payload
98    builder = builder.payload(*record.args());
99
100    // key-values
101    #[cfg(not(feature = "serde"))]
102    {
103        let kvs = kv::key_values_stage_one(record.key_values());
104        let new_kvs = kv::key_value_stage_two(&kvs);
105        builder = builder.key_values(new_kvs.to_key_values());
106        Logger::log(logger, &builder.build());
107    }
108
109    #[cfg(feature = "serde")]
110    {
111        let kvs = kv::key_values(record.key_values());
112        builder = builder.key_values(kvs.to_key_values());
113        Logger::log(logger, &builder.build());
114    }
115}
116
117fn level_to_level(level: log::Level) -> logforth_core::record::Level {
118    match level {
119        log::Level::Error => logforth_core::record::Level::Error,
120        log::Level::Warn => logforth_core::record::Level::Warn,
121        log::Level::Info => logforth_core::record::Level::Info,
122        log::Level::Debug => logforth_core::record::Level::Debug,
123        log::Level::Trace => logforth_core::record::Level::Trace,
124    }
125}
126
127#[cfg(not(feature = "serde"))]
128mod kv {
129    pub(super) struct KeyValuesStageOne<'a> {
130        kvs: Vec<(KeyStageOne<'a>, ValueStageOne<'a>)>,
131    }
132
133    struct KeyStageOne<'a>(log::kv::Key<'a>);
134
135    struct ValueStageOne<'a>(MaybeOwnedValue<'a>);
136
137    enum MaybeOwnedValue<'a> {
138        Borrowed(logforth_core::kv::Value<'a>),
139        Owned(String),
140    }
141
142    pub(super) fn key_values_stage_one<'a>(
143        source: &'a dyn log::kv::Source,
144    ) -> KeyValuesStageOne<'a> {
145        let mut kvs = Vec::with_capacity(log::kv::Source::count(source));
146
147        struct KeyValueVisitor<'a, 'b> {
148            kvs: &'b mut Vec<(KeyStageOne<'a>, ValueStageOne<'a>)>,
149        }
150
151        impl<'a, 'b> log::kv::VisitSource<'a> for KeyValueVisitor<'a, 'b> {
152            fn visit_pair(
153                &mut self,
154                key: log::kv::Key<'a>,
155                value: log::kv::Value<'a>,
156            ) -> Result<(), log::kv::Error> {
157                let key = KeyStageOne(key);
158                let value = ValueStageOne(value_to_value(value));
159                self.kvs.push((key, value));
160                Ok(())
161            }
162        }
163
164        let mut visitor = KeyValueVisitor { kvs: &mut kvs };
165        log::kv::Source::visit(source, &mut visitor).unwrap();
166        KeyValuesStageOne { kvs }
167    }
168
169    fn value_to_value(value: log::kv::Value) -> MaybeOwnedValue {
170        struct ValueVisitor<'a>(MaybeOwnedValue<'a>);
171
172        impl<'a> log::kv::VisitValue<'a> for ValueVisitor<'a> {
173            fn visit_any(&mut self, value: log::kv::Value) -> Result<(), log::kv::Error> {
174                self.0 = MaybeOwnedValue::Owned(value.to_string());
175                Ok(())
176            }
177
178            fn visit_null(&mut self) -> Result<(), log::kv::Error> {
179                self.0 = MaybeOwnedValue::Borrowed(logforth_core::kv::Value::none());
180                Ok(())
181            }
182
183            fn visit_u64(&mut self, value: u64) -> Result<(), log::kv::Error> {
184                self.0 = MaybeOwnedValue::Borrowed(logforth_core::kv::Value::u64(value));
185                Ok(())
186            }
187
188            fn visit_i64(&mut self, value: i64) -> Result<(), log::kv::Error> {
189                self.0 = MaybeOwnedValue::Borrowed(logforth_core::kv::Value::i64(value));
190                Ok(())
191            }
192
193            fn visit_u128(&mut self, value: u128) -> Result<(), log::kv::Error> {
194                self.0 = MaybeOwnedValue::Borrowed(logforth_core::kv::Value::u128(value));
195                Ok(())
196            }
197
198            fn visit_i128(&mut self, value: i128) -> Result<(), log::kv::Error> {
199                self.0 = MaybeOwnedValue::Borrowed(logforth_core::kv::Value::i128(value));
200                Ok(())
201            }
202
203            fn visit_f64(&mut self, value: f64) -> Result<(), log::kv::Error> {
204                self.0 = MaybeOwnedValue::Borrowed(logforth_core::kv::Value::f64(value));
205                Ok(())
206            }
207
208            fn visit_bool(&mut self, value: bool) -> Result<(), log::kv::Error> {
209                self.0 = MaybeOwnedValue::Borrowed(logforth_core::kv::Value::bool(value));
210                Ok(())
211            }
212
213            fn visit_str(&mut self, value: &str) -> Result<(), log::kv::Error> {
214                self.0 = MaybeOwnedValue::Owned(value.to_string());
215                Ok(())
216            }
217
218            fn visit_borrowed_str(&mut self, value: &'a str) -> Result<(), log::kv::Error> {
219                self.0 = MaybeOwnedValue::Borrowed(logforth_core::kv::Value::str(value));
220                Ok(())
221            }
222
223            fn visit_char(&mut self, value: char) -> Result<(), log::kv::Error> {
224                self.0 = MaybeOwnedValue::Borrowed(logforth_core::kv::Value::char(value));
225                Ok(())
226            }
227        }
228
229        let mut visitor = ValueVisitor(MaybeOwnedValue::Borrowed(logforth_core::kv::Value::none()));
230        value.visit(&mut visitor).unwrap();
231        visitor.0
232    }
233
234    pub(super) struct KeyValuesStageTwo<'a> {
235        kvs: Vec<(KeyStageTwo<'a>, ValueStageTwo<'a>)>,
236    }
237
238    impl<'a> KeyValuesStageTwo<'a> {
239        pub(super) fn to_key_values(&self) -> logforth_core::kv::KeyValues<'_> {
240            logforth_core::kv::KeyValues::from(self.kvs.as_slice())
241        }
242    }
243
244    type KeyStageTwo<'a> = logforth_core::kv::Key<'a>;
245
246    type ValueStageTwo<'a> = logforth_core::kv::Value<'a>;
247
248    pub(super) fn key_value_stage_two<'a>(kvs: &'a KeyValuesStageOne<'a>) -> KeyValuesStageTwo<'a> {
249        let mut new_kvs = Vec::with_capacity(kvs.kvs.len());
250        for (k, v) in &kvs.kvs {
251            let k = logforth_core::kv::Key::borrowed(k.0.as_str());
252            let v = match &v.0 {
253                MaybeOwnedValue::Borrowed(v) => v.clone(),
254                MaybeOwnedValue::Owned(s) => logforth_core::kv::Value::str(s.as_str()),
255            };
256            new_kvs.push((k, v));
257        }
258        KeyValuesStageTwo { kvs: new_kvs }
259    }
260}
261
262#[cfg(feature = "serde")]
263mod kv {
264    use std::collections::HashMap;
265    use std::fmt;
266    use std::marker::PhantomData;
267
268    use logforth_core::kv::KeyOwned;
269    use logforth_core::kv::ValueOwned;
270    use logforth_core::kv::ValueView;
271
272    pub(super) struct KeyValues<'a> {
273        kvs: Vec<(KeyOwned, ValueOwned)>,
274        p: PhantomData<&'a ()>,
275    }
276
277    impl<'a> KeyValues<'a> {
278        pub(super) fn to_key_values(&self) -> logforth_core::kv::KeyValues<'_> {
279            logforth_core::kv::KeyValues::from(self.kvs.as_slice())
280        }
281    }
282
283    pub(super) fn key_values<'a>(source: &'a dyn log::kv::Source) -> KeyValues<'a> {
284        struct KeyValueVisitor(Vec<(KeyOwned, ValueOwned)>);
285
286        impl<'a> log::kv::VisitSource<'a> for KeyValueVisitor {
287            fn visit_pair(
288                &mut self,
289                key: log::kv::Key<'a>,
290                value: log::kv::Value<'a>,
291            ) -> Result<(), log::kv::Error> {
292                // TODO(@tisonkun): see https://github.com/rust-lang/log/pull/727
293                let key = KeyOwned::new(key.to_string());
294                if let Some(value) = value_to_value(value) {
295                    self.0.push((key, value));
296                }
297                Ok(())
298            }
299        }
300
301        let mut visitor = KeyValueVisitor(Vec::with_capacity(log::kv::Source::count(source)));
302        log::kv::Source::visit(source, &mut visitor).unwrap();
303
304        KeyValues {
305            kvs: visitor.0,
306            p: PhantomData,
307        }
308    }
309
310    // this is derived from `opentelemetry-appender-log`'s serde impl:
311    // https://github.com/open-telemetry/opentelemetry-rust/blob/f7b0dd99/opentelemetry-appender-log/src/lib.rs#L304-L763
312    fn value_to_value(value: impl serde::Serialize) -> Option<ValueOwned> {
313        value.serialize(ValueSerializer).ok()
314    }
315
316    struct ValueSerializer;
317
318    struct ValueSerializeSeq {
319        value: Vec<ValueOwned>,
320    }
321
322    struct ValueSerializeTuple {
323        value: Vec<ValueOwned>,
324    }
325
326    struct ValueSerializeTupleStruct {
327        value: Vec<ValueOwned>,
328    }
329
330    struct ValueSerializeMap {
331        key: Option<KeyOwned>,
332        value: HashMap<KeyOwned, ValueOwned>,
333    }
334
335    struct ValueSerializeStruct {
336        value: HashMap<KeyOwned, ValueOwned>,
337    }
338
339    struct ValueSerializeTupleVariant {
340        variant: &'static str,
341        value: Vec<ValueOwned>,
342    }
343
344    struct ValueSerializeStructVariant {
345        variant: &'static str,
346        value: HashMap<KeyOwned, ValueOwned>,
347    }
348
349    #[derive(Debug)]
350    struct ValueError(String);
351
352    impl fmt::Display for ValueError {
353        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
354            fmt::Display::fmt(&self.0, f)
355        }
356    }
357
358    impl serde::ser::Error for ValueError {
359        fn custom<T>(msg: T) -> Self
360        where
361            T: fmt::Display,
362        {
363            ValueError(msg.to_string())
364        }
365    }
366
367    impl std::error::Error for ValueError {}
368
369    impl serde::Serializer for ValueSerializer {
370        type Ok = ValueOwned;
371
372        type Error = ValueError;
373
374        type SerializeSeq = ValueSerializeSeq;
375
376        type SerializeTuple = ValueSerializeTuple;
377
378        type SerializeTupleStruct = ValueSerializeTupleStruct;
379
380        type SerializeTupleVariant = ValueSerializeTupleVariant;
381
382        type SerializeMap = ValueSerializeMap;
383
384        type SerializeStruct = ValueSerializeStruct;
385
386        type SerializeStructVariant = ValueSerializeStructVariant;
387
388        fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
389            Ok(ValueOwned::bool(v))
390        }
391
392        fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
393            self.serialize_i64(v as i64)
394        }
395
396        fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
397            self.serialize_i64(v as i64)
398        }
399
400        fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
401            self.serialize_i64(v as i64)
402        }
403
404        fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
405            Ok(ValueOwned::i64(v))
406        }
407
408        fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
409            if let Ok(v) = v.try_into() {
410                self.serialize_i64(v)
411            } else {
412                self.collect_str(&v)
413            }
414        }
415
416        fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
417            self.serialize_u64(v as u64)
418        }
419
420        fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
421            self.serialize_u64(v as u64)
422        }
423
424        fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
425            self.serialize_u64(v as u64)
426        }
427
428        fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
429            Ok(ValueOwned::u64(v))
430        }
431
432        fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
433            if let Ok(v) = v.try_into() {
434                self.serialize_u64(v)
435            } else {
436                self.collect_str(&v)
437            }
438        }
439
440        fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
441            self.serialize_f64(v as f64)
442        }
443
444        fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
445            Ok(ValueOwned::f64(v))
446        }
447
448        fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
449            Ok(ValueOwned::char(v))
450        }
451
452        fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
453            Ok(ValueOwned::str(v.to_string()))
454        }
455
456        fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
457            Ok(ValueOwned::bytes(v.to_vec()))
458        }
459
460        fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
461            Ok(ValueOwned::none())
462        }
463
464        fn serialize_some<T: serde::Serialize + ?Sized>(
465            self,
466            value: &T,
467        ) -> Result<Self::Ok, Self::Error> {
468            value.serialize(self)
469        }
470
471        fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
472            Ok(ValueOwned::none())
473        }
474
475        fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
476            Ok(ValueOwned::str(name))
477        }
478
479        fn serialize_unit_variant(
480            self,
481            _: &'static str,
482            _: u32,
483            variant: &'static str,
484        ) -> Result<Self::Ok, Self::Error> {
485            Ok(ValueOwned::str(variant))
486        }
487
488        fn serialize_newtype_struct<T: serde::Serialize + ?Sized>(
489            self,
490            _: &'static str,
491            value: &T,
492        ) -> Result<Self::Ok, Self::Error> {
493            value.serialize(self)
494        }
495
496        fn serialize_newtype_variant<T: serde::Serialize + ?Sized>(
497            self,
498            _: &'static str,
499            _: u32,
500            variant: &'static str,
501            value: &T,
502        ) -> Result<Self::Ok, Self::Error> {
503            let mut map = self.serialize_map(Some(1))?;
504            serde::ser::SerializeMap::serialize_entry(&mut map, variant, value)?;
505            serde::ser::SerializeMap::end(map)
506        }
507
508        fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
509            Ok(ValueSerializeSeq { value: vec![] })
510        }
511
512        fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
513            Ok(ValueSerializeTuple { value: vec![] })
514        }
515
516        fn serialize_tuple_struct(
517            self,
518            _: &'static str,
519            _: usize,
520        ) -> Result<Self::SerializeTupleStruct, Self::Error> {
521            Ok(ValueSerializeTupleStruct { value: vec![] })
522        }
523
524        fn serialize_tuple_variant(
525            self,
526            _: &'static str,
527            _: u32,
528            variant: &'static str,
529            _: usize,
530        ) -> Result<Self::SerializeTupleVariant, Self::Error> {
531            Ok(ValueSerializeTupleVariant {
532                variant,
533                value: vec![],
534            })
535        }
536
537        fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
538            Ok(ValueSerializeMap {
539                key: None,
540                value: HashMap::new(),
541            })
542        }
543
544        fn serialize_struct(
545            self,
546            _: &'static str,
547            _: usize,
548        ) -> Result<Self::SerializeStruct, Self::Error> {
549            Ok(ValueSerializeStruct {
550                value: HashMap::new(),
551            })
552        }
553
554        fn serialize_struct_variant(
555            self,
556            _: &'static str,
557            _: u32,
558            variant: &'static str,
559            _: usize,
560        ) -> Result<Self::SerializeStructVariant, Self::Error> {
561            Ok(ValueSerializeStructVariant {
562                variant,
563                value: HashMap::new(),
564            })
565        }
566    }
567
568    impl serde::ser::SerializeSeq for ValueSerializeSeq {
569        type Ok = ValueOwned;
570
571        type Error = ValueError;
572
573        fn serialize_element<T: serde::Serialize + ?Sized>(
574            &mut self,
575            value: &T,
576        ) -> Result<(), Self::Error> {
577            self.value.push(value.serialize(ValueSerializer)?);
578            Ok(())
579        }
580
581        fn end(self) -> Result<Self::Ok, Self::Error> {
582            Ok(ValueOwned::from_vec(self.value))
583        }
584    }
585
586    impl serde::ser::SerializeTuple for ValueSerializeTuple {
587        type Ok = ValueOwned;
588
589        type Error = ValueError;
590
591        fn serialize_element<T: serde::Serialize + ?Sized>(
592            &mut self,
593            value: &T,
594        ) -> Result<(), Self::Error> {
595            self.value.push(value.serialize(ValueSerializer)?);
596            Ok(())
597        }
598
599        fn end(self) -> Result<Self::Ok, Self::Error> {
600            Ok(ValueOwned::from_vec(self.value))
601        }
602    }
603
604    impl serde::ser::SerializeTupleStruct for ValueSerializeTupleStruct {
605        type Ok = ValueOwned;
606
607        type Error = ValueError;
608
609        fn serialize_field<T: serde::Serialize + ?Sized>(
610            &mut self,
611            value: &T,
612        ) -> Result<(), Self::Error> {
613            self.value.push(value.serialize(ValueSerializer)?);
614            Ok(())
615        }
616
617        fn end(self) -> Result<Self::Ok, Self::Error> {
618            Ok(ValueOwned::from_vec(self.value))
619        }
620    }
621
622    impl serde::ser::SerializeTupleVariant for ValueSerializeTupleVariant {
623        type Ok = ValueOwned;
624
625        type Error = ValueError;
626
627        fn serialize_field<T: serde::Serialize + ?Sized>(
628            &mut self,
629            value: &T,
630        ) -> Result<(), Self::Error> {
631            self.value.push(value.serialize(ValueSerializer)?);
632            Ok(())
633        }
634
635        fn end(self) -> Result<Self::Ok, Self::Error> {
636            Ok(ValueOwned::from_hash_map({
637                let mut variant = HashMap::<KeyOwned, ValueOwned>::new();
638                variant.insert(KeyOwned::new(self.variant), ValueOwned::list(self.value));
639                variant
640            }))
641        }
642    }
643
644    impl serde::ser::SerializeMap for ValueSerializeMap {
645        type Ok = ValueOwned;
646
647        type Error = ValueError;
648
649        fn serialize_key<T: serde::Serialize + ?Sized>(
650            &mut self,
651            key: &T,
652        ) -> Result<(), Self::Error> {
653            let key = match key.serialize(ValueSerializer)?.view() {
654                ValueView::StaticStr(s) => KeyOwned::new(s),
655                value => KeyOwned::new(value.to_string()),
656            };
657            self.key = Some(key);
658            Ok(())
659        }
660
661        fn serialize_value<T: serde::Serialize + ?Sized>(
662            &mut self,
663            value: &T,
664        ) -> Result<(), Self::Error> {
665            let key = self
666                .key
667                .take()
668                .ok_or_else(|| serde::ser::Error::custom("missing key"))?;
669            let value = value.serialize(ValueSerializer)?;
670            self.value.insert(key, value);
671            Ok(())
672        }
673
674        fn end(self) -> Result<Self::Ok, Self::Error> {
675            Ok(ValueOwned::from_hash_map(self.value))
676        }
677    }
678
679    impl serde::ser::SerializeStruct for ValueSerializeStruct {
680        type Ok = ValueOwned;
681
682        type Error = ValueError;
683
684        fn serialize_field<T: serde::Serialize + ?Sized>(
685            &mut self,
686            key: &'static str,
687            value: &T,
688        ) -> Result<(), Self::Error> {
689            let key = KeyOwned::new(key);
690            let value = value.serialize(ValueSerializer)?;
691            self.value.insert(key, value);
692            Ok(())
693        }
694
695        fn end(self) -> Result<Self::Ok, Self::Error> {
696            Ok(ValueOwned::from_hash_map(self.value))
697        }
698    }
699
700    impl serde::ser::SerializeStructVariant for ValueSerializeStructVariant {
701        type Ok = ValueOwned;
702
703        type Error = ValueError;
704
705        fn serialize_field<T: serde::Serialize + ?Sized>(
706            &mut self,
707            key: &'static str,
708            value: &T,
709        ) -> Result<(), Self::Error> {
710            let key = KeyOwned::new(key);
711            let value = value.serialize(ValueSerializer)?;
712            self.value.insert(key, value);
713            Ok(())
714        }
715
716        fn end(self) -> Result<Self::Ok, Self::Error> {
717            Ok(ValueOwned::from_hash_map({
718                let mut variant = HashMap::<KeyOwned, ValueOwned>::new();
719                variant.insert(
720                    KeyOwned::new(self.variant),
721                    ValueOwned::from_hash_map(self.value),
722                );
723                variant
724            }))
725        }
726    }
727}
logforth_bridge_log/lib.rs

logforth_bridge_log/
lib.rs
