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 = if let Some(k) = k.0.to_static_str() {
252                logforth_core::kv::Key::new(k)
253            } else {
254                logforth_core::kv::Key::borrowed(k.0.as_str())
255            };
256            let v = match &v.0 {
257                MaybeOwnedValue::Borrowed(v) => v.clone(),
258                MaybeOwnedValue::Owned(s) => logforth_core::kv::Value::str(s.as_str()),
259            };
260            new_kvs.push((k, v));
261        }
262        KeyValuesStageTwo { kvs: new_kvs }
263    }
264}
265
266#[cfg(feature = "serde")]
267mod kv {
268    use std::collections::HashMap;
269    use std::fmt;
270    use std::marker::PhantomData;
271
272    use logforth_core::kv::KeyOwned;
273    use logforth_core::kv::ValueOwned;
274    use logforth_core::kv::ValueView;
275
276    pub(super) struct KeyValues<'a> {
277        kvs: Vec<(KeyOwned, ValueOwned)>,
278        p: PhantomData<&'a ()>,
279    }
280
281    impl<'a> KeyValues<'a> {
282        pub(super) fn to_key_values(&self) -> logforth_core::kv::KeyValues<'_> {
283            logforth_core::kv::KeyValues::from(self.kvs.as_slice())
284        }
285    }
286
287    pub(super) fn key_values<'a>(source: &'a dyn log::kv::Source) -> KeyValues<'a> {
288        struct KeyValueVisitor(Vec<(KeyOwned, ValueOwned)>);
289
290        impl<'a> log::kv::VisitSource<'a> for KeyValueVisitor {
291            fn visit_pair(
292                &mut self,
293                key: log::kv::Key<'a>,
294                value: log::kv::Value<'a>,
295            ) -> Result<(), log::kv::Error> {
296                let key = if let Some(key) = key.to_static_str() {
297                    KeyOwned::new(key)
298                } else {
299                    KeyOwned::new(key.to_string())
300                };
301                if let Some(value) = value_to_value(value) {
302                    self.0.push((key, value));
303                }
304                Ok(())
305            }
306        }
307
308        let mut visitor = KeyValueVisitor(Vec::with_capacity(log::kv::Source::count(source)));
309        log::kv::Source::visit(source, &mut visitor).unwrap();
310
311        KeyValues {
312            kvs: visitor.0,
313            p: PhantomData,
314        }
315    }
316
317    // this is derived from `opentelemetry-appender-log`'s serde impl:
318    // https://github.com/open-telemetry/opentelemetry-rust/blob/f7b0dd99/opentelemetry-appender-log/src/lib.rs#L304-L763
319    fn value_to_value(value: impl serde::Serialize) -> Option<ValueOwned> {
320        value.serialize(ValueSerializer).ok()
321    }
322
323    struct ValueSerializer;
324
325    struct ValueSerializeSeq {
326        value: Vec<ValueOwned>,
327    }
328
329    struct ValueSerializeTuple {
330        value: Vec<ValueOwned>,
331    }
332
333    struct ValueSerializeTupleStruct {
334        value: Vec<ValueOwned>,
335    }
336
337    struct ValueSerializeMap {
338        key: Option<KeyOwned>,
339        value: HashMap<KeyOwned, ValueOwned>,
340    }
341
342    struct ValueSerializeStruct {
343        value: HashMap<KeyOwned, ValueOwned>,
344    }
345
346    struct ValueSerializeTupleVariant {
347        variant: &'static str,
348        value: Vec<ValueOwned>,
349    }
350
351    struct ValueSerializeStructVariant {
352        variant: &'static str,
353        value: HashMap<KeyOwned, ValueOwned>,
354    }
355
356    #[derive(Debug)]
357    struct ValueError(String);
358
359    impl fmt::Display for ValueError {
360        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
361            fmt::Display::fmt(&self.0, f)
362        }
363    }
364
365    impl serde::ser::Error for ValueError {
366        fn custom<T>(msg: T) -> Self
367        where
368            T: fmt::Display,
369        {
370            ValueError(msg.to_string())
371        }
372    }
373
374    impl std::error::Error for ValueError {}
375
376    impl serde::Serializer for ValueSerializer {
377        type Ok = ValueOwned;
378
379        type Error = ValueError;
380
381        type SerializeSeq = ValueSerializeSeq;
382
383        type SerializeTuple = ValueSerializeTuple;
384
385        type SerializeTupleStruct = ValueSerializeTupleStruct;
386
387        type SerializeTupleVariant = ValueSerializeTupleVariant;
388
389        type SerializeMap = ValueSerializeMap;
390
391        type SerializeStruct = ValueSerializeStruct;
392
393        type SerializeStructVariant = ValueSerializeStructVariant;
394
395        fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
396            Ok(ValueOwned::bool(v))
397        }
398
399        fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
400            self.serialize_i64(v as i64)
401        }
402
403        fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
404            self.serialize_i64(v as i64)
405        }
406
407        fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
408            self.serialize_i64(v as i64)
409        }
410
411        fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
412            Ok(ValueOwned::i64(v))
413        }
414
415        fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
416            if let Ok(v) = v.try_into() {
417                self.serialize_i64(v)
418            } else {
419                self.collect_str(&v)
420            }
421        }
422
423        fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
424            self.serialize_u64(v as u64)
425        }
426
427        fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
428            self.serialize_u64(v as u64)
429        }
430
431        fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
432            self.serialize_u64(v as u64)
433        }
434
435        fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
436            Ok(ValueOwned::u64(v))
437        }
438
439        fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
440            if let Ok(v) = v.try_into() {
441                self.serialize_u64(v)
442            } else {
443                self.collect_str(&v)
444            }
445        }
446
447        fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
448            self.serialize_f64(v as f64)
449        }
450
451        fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
452            Ok(ValueOwned::f64(v))
453        }
454
455        fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
456            Ok(ValueOwned::char(v))
457        }
458
459        fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
460            Ok(ValueOwned::str(v.to_string()))
461        }
462
463        fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
464            Ok(ValueOwned::bytes(v.to_vec()))
465        }
466
467        fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
468            Ok(ValueOwned::none())
469        }
470
471        fn serialize_some<T: serde::Serialize + ?Sized>(
472            self,
473            value: &T,
474        ) -> Result<Self::Ok, Self::Error> {
475            value.serialize(self)
476        }
477
478        fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
479            Ok(ValueOwned::none())
480        }
481
482        fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
483            Ok(ValueOwned::str(name))
484        }
485
486        fn serialize_unit_variant(
487            self,
488            _: &'static str,
489            _: u32,
490            variant: &'static str,
491        ) -> Result<Self::Ok, Self::Error> {
492            Ok(ValueOwned::str(variant))
493        }
494
495        fn serialize_newtype_struct<T: serde::Serialize + ?Sized>(
496            self,
497            _: &'static str,
498            value: &T,
499        ) -> Result<Self::Ok, Self::Error> {
500            value.serialize(self)
501        }
502
503        fn serialize_newtype_variant<T: serde::Serialize + ?Sized>(
504            self,
505            _: &'static str,
506            _: u32,
507            variant: &'static str,
508            value: &T,
509        ) -> Result<Self::Ok, Self::Error> {
510            let mut map = self.serialize_map(Some(1))?;
511            serde::ser::SerializeMap::serialize_entry(&mut map, variant, value)?;
512            serde::ser::SerializeMap::end(map)
513        }
514
515        fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
516            Ok(ValueSerializeSeq { value: vec![] })
517        }
518
519        fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
520            Ok(ValueSerializeTuple { value: vec![] })
521        }
522
523        fn serialize_tuple_struct(
524            self,
525            _: &'static str,
526            _: usize,
527        ) -> Result<Self::SerializeTupleStruct, Self::Error> {
528            Ok(ValueSerializeTupleStruct { value: vec![] })
529        }
530
531        fn serialize_tuple_variant(
532            self,
533            _: &'static str,
534            _: u32,
535            variant: &'static str,
536            _: usize,
537        ) -> Result<Self::SerializeTupleVariant, Self::Error> {
538            Ok(ValueSerializeTupleVariant {
539                variant,
540                value: vec![],
541            })
542        }
543
544        fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
545            Ok(ValueSerializeMap {
546                key: None,
547                value: HashMap::new(),
548            })
549        }
550
551        fn serialize_struct(
552            self,
553            _: &'static str,
554            _: usize,
555        ) -> Result<Self::SerializeStruct, Self::Error> {
556            Ok(ValueSerializeStruct {
557                value: HashMap::new(),
558            })
559        }
560
561        fn serialize_struct_variant(
562            self,
563            _: &'static str,
564            _: u32,
565            variant: &'static str,
566            _: usize,
567        ) -> Result<Self::SerializeStructVariant, Self::Error> {
568            Ok(ValueSerializeStructVariant {
569                variant,
570                value: HashMap::new(),
571            })
572        }
573    }
574
575    impl serde::ser::SerializeSeq for ValueSerializeSeq {
576        type Ok = ValueOwned;
577
578        type Error = ValueError;
579
580        fn serialize_element<T: serde::Serialize + ?Sized>(
581            &mut self,
582            value: &T,
583        ) -> Result<(), Self::Error> {
584            self.value.push(value.serialize(ValueSerializer)?);
585            Ok(())
586        }
587
588        fn end(self) -> Result<Self::Ok, Self::Error> {
589            Ok(ValueOwned::from_vec(self.value))
590        }
591    }
592
593    impl serde::ser::SerializeTuple for ValueSerializeTuple {
594        type Ok = ValueOwned;
595
596        type Error = ValueError;
597
598        fn serialize_element<T: serde::Serialize + ?Sized>(
599            &mut self,
600            value: &T,
601        ) -> Result<(), Self::Error> {
602            self.value.push(value.serialize(ValueSerializer)?);
603            Ok(())
604        }
605
606        fn end(self) -> Result<Self::Ok, Self::Error> {
607            Ok(ValueOwned::from_vec(self.value))
608        }
609    }
610
611    impl serde::ser::SerializeTupleStruct for ValueSerializeTupleStruct {
612        type Ok = ValueOwned;
613
614        type Error = ValueError;
615
616        fn serialize_field<T: serde::Serialize + ?Sized>(
617            &mut self,
618            value: &T,
619        ) -> Result<(), Self::Error> {
620            self.value.push(value.serialize(ValueSerializer)?);
621            Ok(())
622        }
623
624        fn end(self) -> Result<Self::Ok, Self::Error> {
625            Ok(ValueOwned::from_vec(self.value))
626        }
627    }
628
629    impl serde::ser::SerializeTupleVariant for ValueSerializeTupleVariant {
630        type Ok = ValueOwned;
631
632        type Error = ValueError;
633
634        fn serialize_field<T: serde::Serialize + ?Sized>(
635            &mut self,
636            value: &T,
637        ) -> Result<(), Self::Error> {
638            self.value.push(value.serialize(ValueSerializer)?);
639            Ok(())
640        }
641
642        fn end(self) -> Result<Self::Ok, Self::Error> {
643            Ok(ValueOwned::from_hash_map({
644                let mut variant = HashMap::<KeyOwned, ValueOwned>::new();
645                variant.insert(KeyOwned::new(self.variant), ValueOwned::list(self.value));
646                variant
647            }))
648        }
649    }
650
651    impl serde::ser::SerializeMap for ValueSerializeMap {
652        type Ok = ValueOwned;
653
654        type Error = ValueError;
655
656        fn serialize_key<T: serde::Serialize + ?Sized>(
657            &mut self,
658            key: &T,
659        ) -> Result<(), Self::Error> {
660            let key = match key.serialize(ValueSerializer)?.view() {
661                ValueView::StaticStr(s) => KeyOwned::new(s),
662                value => KeyOwned::new(value.to_string()),
663            };
664            self.key = Some(key);
665            Ok(())
666        }
667
668        fn serialize_value<T: serde::Serialize + ?Sized>(
669            &mut self,
670            value: &T,
671        ) -> Result<(), Self::Error> {
672            let key = self
673                .key
674                .take()
675                .ok_or_else(|| serde::ser::Error::custom("missing key"))?;
676            let value = value.serialize(ValueSerializer)?;
677            self.value.insert(key, value);
678            Ok(())
679        }
680
681        fn end(self) -> Result<Self::Ok, Self::Error> {
682            Ok(ValueOwned::from_hash_map(self.value))
683        }
684    }
685
686    impl serde::ser::SerializeStruct for ValueSerializeStruct {
687        type Ok = ValueOwned;
688
689        type Error = ValueError;
690
691        fn serialize_field<T: serde::Serialize + ?Sized>(
692            &mut self,
693            key: &'static str,
694            value: &T,
695        ) -> Result<(), Self::Error> {
696            let key = KeyOwned::new(key);
697            let value = value.serialize(ValueSerializer)?;
698            self.value.insert(key, value);
699            Ok(())
700        }
701
702        fn end(self) -> Result<Self::Ok, Self::Error> {
703            Ok(ValueOwned::from_hash_map(self.value))
704        }
705    }
706
707    impl serde::ser::SerializeStructVariant for ValueSerializeStructVariant {
708        type Ok = ValueOwned;
709
710        type Error = ValueError;
711
712        fn serialize_field<T: serde::Serialize + ?Sized>(
713            &mut self,
714            key: &'static str,
715            value: &T,
716        ) -> Result<(), Self::Error> {
717            let key = KeyOwned::new(key);
718            let value = value.serialize(ValueSerializer)?;
719            self.value.insert(key, value);
720            Ok(())
721        }
722
723        fn end(self) -> Result<Self::Ok, Self::Error> {
724            Ok(ValueOwned::from_hash_map({
725                let mut variant = HashMap::<KeyOwned, ValueOwned>::new();
726                variant.insert(
727                    KeyOwned::new(self.variant),
728                    ValueOwned::from_hash_map(self.value),
729                );
730                variant
731            }))
732        }
733    }
734}
logforth_bridge_log/lib.rs

logforth_bridge_log/
lib.rs
