LogSinks.hh

Go to the documentation of this file.

//
// LogSinks.hh
//
// Copyright (c) 2025 Couchbase, Inc All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
 
 
#pragma once
#include "cbl/CBLLogSinks.h"
#include "cbl++/Base.hh"
#include "cbl/CBLDefaults.h"
 
CBL_ASSUME_NONNULL_BEGIN
 
namespace cbl {
 
    using LogDomainMask   = CBLLogDomainMask;
    using LogSinkCallback = CBLLogSinkCallback;
    using LogLevel        = CBLLogLevel;
    using LogDomain       = CBLLogDomain;

    struct ConsoleLogSink {
        LogLevel level = kCBLLogNone;           
        LogDomainMask domains;                  
 
        operator CBLConsoleLogSink() const {
            return {(CBLLogLevel)(uint8_t)level, domains};
        }
    };

    struct CustomLogSink {
        LogLevel level = kCBLLogNone;            
        LogSinkCallback _cbl_nullable callback;  
        LogDomainMask domains;                   
 
        operator CBLCustomLogSink() const {
            return {level, callback, domains};
        }
    };

    struct FileLogSink {
        LogLevel level = kCBLLogNone;            
        std::string directory;                   

        uint32_t maxKeptFiles = kCBLDefaultFileLogSinkMaxKeptFiles;

        size_t maxSize = kCBLDefaultFileLogSinkMaxSize;

        bool usePlaintext = kCBLDefaultFileLogSinkUsePlaintext;
    };

    class LogSinks {
    public:
        static void setConsole(const ConsoleLogSink& sink) {
            CBLLogSinks_SetConsole(sink);
        }

        static ConsoleLogSink console() {
            return fromCConfiguration(CBLLogSinks_Console());
        }

        static void setCustom(const CustomLogSink& sink) {
            CBLLogSinks_SetCustom(sink);
        }

        static CustomLogSink custom() {
            return fromCConfiguration(CBLLogSinks_CustomSink());
        }

        static void setFile(FileLogSink sink) {
            CBLLogSinks_SetFile({
                (CBLLogLevel)(uint8_t)sink.level,
                slice(sink.directory),
                sink.maxKeptFiles,
                sink.maxSize,
                sink.usePlaintext
            });
        }

        static FileLogSink file() {
            return fromCConfiguration(CBLLogSinks_File());
        }
 
    private:
        static ConsoleLogSink fromCConfiguration(const CBLConsoleLogSink& cSink) {
            return { cSink.level, cSink.domains};
        }
 
        static CustomLogSink fromCConfiguration(const CBLCustomLogSink& cSink) {
            return { cSink.level, cSink.callback, cSink.domains};
        }
 
        static FileLogSink fromCConfiguration(const CBLFileLogSink& cSink) {
            return {
                cSink.level,
                std::string(cSink.directory),
                cSink.maxKeptFiles,
                cSink.maxSize,
                cSink.usePlaintext
            };
        }
    };
}
 
CBL_ASSUME_NONNULL_END