aboutsummaryrefslogtreecommitdiff
path: root/src/lib.rs
blob: 8f8e15a905d9b340758e5451b35fa3d3dccec0ef (plain) (blame)
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
//! # OpenTelemetry Log Integration
//!
//! This crate provides integration with OpenTelemetry for logging purposes. It allows you to
//! initialize and manage loggers that are compatible with the OpenTelemetry SDK.
//!
//! ## Features
//!
//! - Initialize loggers with specific tags, levels, and exporter endpoints.
//! - Automatically manage the lifecycle of loggers, ensuring proper shutdown.
//!
//! ## Usage
//!
//! Add this crate to your `Cargo.toml`:
//!
//! ```toml
//! [dependencies]
//! opentelemetry-log = "0.1"
//! ```
//!
//! Import and use the `Opentelemetry` struct to manage your loggers:
//!
//! ```rust
//! use opentelemetry_log::Opentelemetry;
//!
//! #[tokio::main]
//! async fn main() {
//!     let mut otel = Opentelemetry::new();
//!     otel.init_log("my_app", "info", "http://localhost:4317").unwrap(); // Please do not unwrap in production code
//!     // Your application logic here
//! }
//! ```
//!
//! ## Modules
//!
//! - `log`: Contains the log initialization logic.
//!
//! ## Structs
//!
//! - `Opentelemetry`: Main struct for managing OpenTelemetry loggers.
//!
//! ## Traits
//!
//! - `Default`: Provides a default implementation for `Opentelemetry`.
//! - `Drop`: Ensures proper shutdown of loggers when `Opentelemetry` instances are dropped.
//!
//! ## Errors
//!
//! This crate uses the `anyhow` crate for error handling. Ensure you handle errors appropriately
//! when initializing and using loggers.
// Copied from https://github.com/vincenzopalazzo/opentelemetry-log/commit/e013d914b63068db53e5a90a537052b32448f5a6
pub mod logger;
pub use anyhow;
use opentelemetry_appender_log::OpenTelemetryLogBridge;

use std::sync::Arc;

use opentelemetry_sdk::logs::{self as sdklogs, Logger, LoggerProvider};

/// Main struct for managing OpenTelemetry loggers, when you init the logger
/// remember to keep this alive for all the lifetime of the application.
///
/// An example can be found in the `examples` directory.
#[derive(Debug, Clone)]
pub struct Opentelemetry {
    pub(crate) logger: Option<Arc<sdklogs::LoggerProvider>>,
}

impl Default for Opentelemetry {
    fn default() -> Self {
        Self::new()
    }
}

impl Opentelemetry {
    pub fn new() -> Self {
        Opentelemetry { logger: None }
    }

    /// Initialize a new logger with the provided tag, level, and exporter endpoint.
    /// this is assuming tat your application is using `log` crate
    pub fn init_log(
        &mut self,
    ) -> Result<OpenTelemetryLogBridge<LoggerProvider, Logger>, ()> {
        logger::init(self)
    }
}

impl Drop for Opentelemetry {
    fn drop(&mut self) {
        let Some(Err(err)) = self.logger.as_ref().map(|log| log.shutdown()) else {
            return;
        };
        eprintln!("Failed to shutdown logger: {:?}", err);
    }
}