telemetry.hxx

Go to the documentation of this file.

/*
 * Copyright (C) 2024-2026 David C. Manuelda (StormBytePP)
 *
 * This file is part of StormByte-Database.
 *
 * SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-StormByte-Commercial
 */
 
#pragma once
 
#include <StormByte/database/visibility.h>
#include <StormByte/safe/pointers.hxx>
#include <StormByte/safe/string.hxx>
#include <StormByte/telemetry.hxx>
#include <StormByte/thread_lock.hxx>
 
#include <array>
#include <atomic>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <string>
 
namespace StormByte {
    namespace Database {
        enum class Operation : std::uint8_t {
            Connect,             
            Disconnect,          
            Query,               
            SilentQuery,         
            PrepareStatement,    
            PreparedStatement,   
            BeginTransaction,    
            CommitTransaction,   
            RollbackTransaction, 
            Count                
        };
 
        enum class BackendEvent : std::uint8_t {
            Warning,       
            Busy,          
            Constraint,    
            Io,            
            Connection,    
            Serialization, 
            Deadlock,      
            LockTimeout,   
            Other,         
            Count          
        };
 
        struct OperationMetrics {
            std::uint64_t Attempts{};         
            std::uint64_t Successes{};        
            std::uint64_t Failures{};         
            std::uint64_t TotalNanoseconds{}; 
            std::uint64_t MinimumNanoseconds{}; 
            std::uint64_t MaximumNanoseconds{}; 
 
            std::uint64_t MeanNanoseconds() const noexcept {
                return Attempts == 0 ? 0 : TotalNanoseconds / Attempts;
            }
        };
 
        class STORMBYTE_DATABASE_PUBLIC Telemetry : public StormByte::Telemetry {
            public:
                class STORMBYTE_DATABASE_PUBLIC OperationScope {
                    public:
                    OperationScope(StormByte::Safe::Shared<Telemetry> telemetry, Operation operation) noexcept;
 
                    OperationScope(const OperationScope&) = delete;
 
                    OperationScope(OperationScope&&) = delete;
 
                    void Complete(bool success, std::uint64_t rows_returned = 0) noexcept;
 
                    ~OperationScope() noexcept;
 
                private:
                    StormByte::Safe::Shared<Telemetry> m_telemetry; 
                    Operation m_operation; 
                    std::chrono::microseconds m_started; 
                    bool m_clock_started; 
                    std::uint64_t m_rows_returned; 
                    bool m_success; 
                    bool m_completed; 
                };
 
                virtual ~Telemetry() noexcept;
 
                Telemetry() noexcept;
 
                OperationMetrics Metrics(Operation operation) const noexcept;
 
                std::uint64_t RowsReturned() const noexcept;
 
                std::uint64_t Events(BackendEvent event) const noexcept;
 
                virtual operator StormByte::Safe::String() const override;
 
                STORMBYTE_FORCE_INLINE operator std::string() const {
                        return static_cast<std::string>(static_cast<StormByte::Safe::String>(*this));
                }
 
            protected:
                Telemetry(const Telemetry&) = delete; 
                Telemetry(Telemetry&&) = delete; 
                Telemetry& operator=(const Telemetry&) = delete; 
                Telemetry& operator=(Telemetry&&) = delete; 
 
                virtual void RecordEvent(BackendEvent event) noexcept;
 
                void RecordEvents(BackendEvent event, std::uint64_t count) noexcept;
 
            private:
                friend class Database;
                friend class PreparedSTMT;
                friend class OperationScope;
 
                mutable std::array<StormByte::ThreadLock, static_cast<std::size_t>(Operation::Count)> m_clock_locks; 
 
                struct Counter {
                    std::atomic<std::uint64_t> successes{0}; 
                    std::atomic<std::uint64_t> failures{0}; 
                    std::atomic<std::uint64_t> minimum_nanoseconds{std::numeric_limits<std::uint64_t>::max()}; 
                    std::atomic<std::uint64_t> maximum_nanoseconds{0}; 
                };
 
                void RecordOperation(Operation operation, bool success, std::chrono::nanoseconds elapsed, std::uint64_t rows_returned) noexcept;
 
                std::array<Counter, static_cast<std::size_t>(Operation::Count)> m_operations; 
                std::array<std::atomic<std::uint64_t>, static_cast<std::size_t>(BackendEvent::Count)> m_events; 
                std::atomic<std::uint64_t> m_rows_returned; 
        };
    }
}