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

#![warn(rust_2018_idioms, unreachable_pub)]

#[macro_use]
extern crate elfo_utils;

use std::{env, sync::Arc, time::SystemTime};

use dashmap::DashMap;
use derive_more::Constructor;
use futures_intrusive::{buffer::GrowingHeapBuf, channel::GenericChannel};
use fxhash::FxBuildHasher;
use parking_lot::RawMutex;
use sharded_slab::Pool;
use tracing::{span::Id as SpanId, Level};
use tracing_subscriber::{prelude::*, registry::Registry, EnvFilter};

use elfo_core::{trace_id::TraceId, Schema, _priv::ObjectMeta};

use crate::{actor::Logger, layer::PrintLayer};

mod actor;
mod config;
mod formatters;
mod layer;
mod theme;

const CHANNEL_CAPACITY: usize = 128 * 1024;

type StringId = usize;

struct Shared {
    channel: GenericChannel<RawMutex, PreparedEvent, GrowingHeapBuf<PreparedEvent>>,
    pool: Pool<String>,
    spans: DashMap<SpanId, SpanData, FxBuildHasher>,
}

#[derive(Constructor)]
struct SpanData {
    parent_id: Option<SpanId>,
    payload_id: StringId,
}

struct PreparedEvent {
    timestamp: SystemTime,
    level: Level,
    trace_id: Option<TraceId>,
    object: Option<Arc<ObjectMeta>>,
    span_id: Option<SpanId>,
    payload_id: StringId,
}

pub fn new() -> (PrintLayer, Schema) {
    let shared = Shared {
        channel: GenericChannel::with_capacity(CHANNEL_CAPACITY),
        pool: Pool::default(),
        spans: DashMap::default(),
    };

    let shared = Arc::new(shared);
    let layer = PrintLayer::new(shared.clone());
    let schema = Logger::new(shared);

    (layer, schema)
}

pub fn init() -> Schema {
    // TODO: log instead of panicking.
    let (print_layer, schema) = new();

    let filter_layer = if env::var(EnvFilter::DEFAULT_ENV).is_ok() {
        EnvFilter::try_from_default_env().expect("invalid env")
    } else {
        EnvFilter::try_new("info").unwrap()
    };

    let subscriber = Registry::default().with(filter_layer).with(print_layer);

    tracing::subscriber::set_global_default(subscriber).expect("cannot set global subscriber");
    schema
}