improve code for obs

crates/obs/examples/config.toml

@@ -0,0 +1,33 @@
+[observability]
+endpoint = "http://localhost:4317" # Default is "http://localhost:4317" if not specified
+use_stdout = false # Output with stdout, true output, false no output
+sample_ratio = 1
+meter_interval = 30
+service_name = "rustfs_obs"
+service_version = "0.1.0"
+environments = "develop"
+logger_level = "debug"
+
+[sinks]
+[sinks.kafka]
+enabled = false
+bootstrap_servers = "localhost:9092"
+topic = "logs"
+batch_size = 100 # Default is 100 if not specified
+batch_timeout_ms = 1000 # Default is 1000ms if not specified
+
+[sinks.webhook]
+enabled = false
+endpoint = "http://localhost:8080/webhook"
+auth_token = ""
+batch_size = 100 # Default is 3 if not specified
+batch_timeout_ms = 1000 # Default is 100ms if not specified
+
+[sinks.file]
+enabled = true
+path = "logs/app.log"
+batch_size = 100
+batch_timeout_ms = 1000 # Default is 8192 bytes if not specified
+
+[logger]
+queue_capacity = 10000

crates/obs/examples/server.rs

@@ -0,0 +1,88 @@
+use opentelemetry::global;
+use rustfs_obs::{get_logger, init_obs, load_config, log_info, BaseLogEntry, ServerLogEntry};
+use std::collections::HashMap;
+use std::time::{Duration, SystemTime};
+use tracing::{info, instrument};
+use tracing_core::Level;
+
+#[tokio::main]
+async fn main() {
+    let obs_conf = Some("packages/obs/examples/config.toml".to_string());
+    let config = load_config(obs_conf);
+    let (_logger, _guard) = init_obs(config.clone()).await;
+    let span = tracing::span!(Level::INFO, "main");
+    let _enter = span.enter();
+    info!("Program starts");
+    // Simulate the operation
+    tokio::time::sleep(Duration::from_millis(100)).await;
+    run(
+        "service-demo".to_string(),
+        "object-demo".to_string(),
+        "user-demo".to_string(),
+        "service-demo".to_string(),
+    )
+    .await;
+    info!("Program ends");
+}
+
+#[instrument(fields(bucket, object, user))]
+async fn run(bucket: String, object: String, user: String, service_name: String) {
+    let start_time = SystemTime::now();
+    info!("Log module initialization is completed service_name: {:?}", service_name);
+
+    // Record Metrics
+    let meter = global::meter("rustfs");
+    let request_duration = meter.f64_histogram("s3_request_duration_seconds").build();
+    request_duration.record(
+        start_time.elapsed().unwrap().as_secs_f64(),
+        &[opentelemetry::KeyValue::new("operation", "run")],
+    );
+
+    let base_entry = BaseLogEntry::new()
+        .message(Some("run logger api_handler info".to_string()))
+        .request_id(Some("request_id".to_string()))
+        .timestamp(chrono::DateTime::from(start_time))
+        .tags(Some(HashMap::default()));
+
+    let server_entry = ServerLogEntry::new(Level::INFO, "api_handler".to_string())
+        .with_base(base_entry)
+        .user_id(Some(user.clone()))
+        .add_field("operation".to_string(), "login".to_string())
+        .add_field("bucket".to_string(), bucket.clone())
+        .add_field("object".to_string(), object.clone());
+
+    let result = get_logger().lock().await.log_server_entry(server_entry).await;
+    info!("Logging is completed {:?}", result);
+    put_object("bucket".to_string(), "object".to_string(), "user".to_string()).await;
+    info!("Logging is completed");
+    tokio::time::sleep(Duration::from_secs(2)).await;
+    info!("Program run ends");
+}
+
+#[instrument(fields(bucket, object, user))]
+async fn put_object(bucket: String, object: String, user: String) {
+    let start_time = SystemTime::now();
+    info!("Starting put_object operation time: {:?}", start_time);
+
+    let meter = global::meter("rustfs");
+    let request_duration = meter.f64_histogram("s3_request_duration_seconds").build();
+    request_duration.record(
+        start_time.elapsed().unwrap().as_secs_f64(),
+        &[opentelemetry::KeyValue::new("operation", "put_object")],
+    );
+
+    info!(
+        "Starting PUT operation content: bucket = {}, object = {}, user = {},start_time = {}",
+        bucket,
+        object,
+        user,
+        start_time.elapsed().unwrap().as_secs_f64()
+    );
+
+    let result = log_info("put_object logger info", "put_object").await;
+    info!("put_object is completed {:?}", result);
+    // Simulate the operation
+    tokio::time::sleep(Duration::from_millis(100)).await;
+
+    info!("PUT operation completed");
+}