logger.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <memory>
#include <vector>
#include <atomic>
#include <thread>
#include <string_view>
 
#include "thread_integration_detector.h"
 
// Use common_system's ILogger interface for standardized logging
#include <kcenon/common/interfaces/logger_interface.h>
 
#include "error_codes.h"
#include "metrics/logger_metrics.h"
#include "../backends/integration_backend.h"
#include <kcenon/logger/interfaces/logger_types.h>
#include <kcenon/logger/interfaces/log_entry.h>
#include <kcenon/logger/interfaces/log_writer_interface.h>
#include <kcenon/logger/logger_export.h>
#include <kcenon/logger/otlp/otel_context.h>
#include <kcenon/logger/sampling/sampling_config.h>
#include <kcenon/logger/security/signal_manager.h>
#include "structured_log_builder.h"
#include "unified_log_context.h"
 
namespace kcenon::logger {
 
// Type aliases - use common::interfaces types for standardization
using log_level = common::interfaces::log_level;
// health_status and overflow_policy are declared directly in this namespace
// via <kcenon/logger/interfaces/logger_types.h> (included above). No further
// aliasing needed — they are already visible as kcenon::logger::health_status
// and kcenon::logger::overflow_policy.
 
// Type aliases for convenience and compatibility
using logger_metrics = metrics::logger_performance_stats;
using performance_metrics = metrics::logger_performance_stats; // Alias for examples
 
enum class metric_type {
    gauge,      
    counter,    
    histogram   
};
 
// Forward declarations
class log_collector;
class base_writer;
class logger_metrics_collector;
class log_filter_interface;  // Forward declaration for filtering system
 
#ifdef LOGGER_WITH_ANALYSIS
namespace analysis {
class realtime_log_analyzer;
}  // namespace analysis
#endif  // LOGGER_WITH_ANALYSIS
 
namespace sampling {
class log_sampler;
}  // namespace sampling
 
} // namespace kcenon::logger
 
// Include routing header for log_router
#include "../routing/log_router.h"
 
namespace kcenon::logger {
 
// Routing type alias
using routing::log_router;
using routing::route_config;
using routing::router_builder;
 
class LOGGER_SYSTEM_API logger : public security::critical_logger_interface,
                                public common::interfaces::ILogger {
public:
    explicit logger(bool async = true, std::size_t buffer_size = 8192,
                   std::unique_ptr<backends::integration_backend> backend = nullptr);
    
    ~logger();
    
    // =========================================================================
    // ILogger interface implementation (common::interfaces::ILogger)
    // =========================================================================
 
    common::VoidResult log(common::interfaces::log_level level,
                           const std::string& message) override;
 
    common::VoidResult log(common::interfaces::log_level level,
                           std::string_view message,
                           const common::source_location& loc = common::source_location::current()) override;
 
    // Legacy log(level, message, file, line, function) removed.
    // Use log(level, message, source_location::current()) instead.
 
    common::VoidResult log(const common::interfaces::log_entry& entry) override;
 
    bool is_enabled(common::interfaces::log_level level) const override;
 
    common::VoidResult set_level(common::interfaces::log_level level) override;
 
    common::interfaces::log_level get_level() const override;
 
    common::VoidResult flush() override;
 
    // Additional logger-specific methods
    
    common::VoidResult add_writer(log_writer_ptr writer);
 
    common::VoidResult clear_writers();
    
    common::VoidResult start();
 
    common::VoidResult stop();
    
    bool is_running() const;
    
    common::VoidResult enable_metrics_collection(bool enable = true);
    
    bool is_metrics_collection_enabled() const;
    
    result<metrics::logger_performance_stats> get_current_metrics() const;
    
    result<std::unique_ptr<metrics::logger_performance_stats>> get_metrics_history(std::chrono::seconds duration) const;
    
    common::VoidResult reset_metrics();
    
    logger_metrics_collector* get_metrics_collector();
    
    common::VoidResult add_writer(const std::string& name, log_writer_ptr writer);
    
    bool remove_writer(const std::string& name);
    
    log_writer_interface* get_writer(const std::string& name);
    
    void set_filter(std::unique_ptr<log_filter_interface> filter);
 
    bool has_filter() const;
 
    // =========================================================================
    // Routing system
    // =========================================================================
 
    log_router& get_router();
 
    const log_router& get_router() const;
 
    void set_router(std::unique_ptr<log_router> router);
 
    bool has_routing() const;
 
    // =========================================================================
    // Real-time analysis (optional, requires LOGGER_WITH_ANALYSIS)
    // =========================================================================
 
#ifdef LOGGER_WITH_ANALYSIS
    void set_realtime_analyzer(std::unique_ptr<analysis::realtime_log_analyzer> analyzer);
 
    [[nodiscard]] analysis::realtime_log_analyzer* get_realtime_analyzer();
 
    [[nodiscard]] const analysis::realtime_log_analyzer* get_realtime_analyzer() const;
 
    [[nodiscard]] bool has_realtime_analysis() const;
#endif  // LOGGER_WITH_ANALYSIS
 
    // OpenTelemetry context: Use context().set_otel(), context().get_string("otel_trace_id"),
    // context().clear(context_category::otel), context().has("otel_trace_id") instead.
 
    // =========================================================================
    // Structured logging API
    // =========================================================================
 
    [[nodiscard]] structured_log_builder log_structured(log_level level);
 
    // =========================================================================
    // Unified Context API (NEW)
    // =========================================================================
 
    [[nodiscard]] unified_log_context& context();
 
    [[nodiscard]] const unified_log_context& context() const;
 
    // Legacy context fields: Use context().set(key, value) and context().remove(key) instead.
 
    // =========================================================================
    // Log sampling API
    // =========================================================================
 
    void set_sampler(std::unique_ptr<sampling::log_sampler> sampler);
 
    [[nodiscard]] sampling::log_sampler* get_sampler();
 
    [[nodiscard]] const sampling::log_sampler* get_sampler() const;
 
    [[nodiscard]] bool has_sampling() const;
 
    [[nodiscard]] sampling::sampling_stats get_sampling_stats() const;
 
    void reset_sampling_stats();
 
    // Emergency Flush Support (critical_logger_interface implementation)
 
    int get_emergency_fd() const override;
 
    const char* get_emergency_buffer() const override;
 
    size_t get_emergency_buffer_size() const override;
 
private:
    class impl;
    std::unique_ptr<impl> pimpl_;
};
 
} // namespace kcenon::logger