2103

Committed 06 Mar 2024 03:32PM UTC coverage: 90.949% (+0.02%) from 90.931%

Build # 2103

Build Type

push

Evergreen

Committed by

web-flow

Commit Message

Merge pull request #7419 from realm/je/logging-c-api

Add ability to get logging level via C API.
Add ability to get all category names

Run Details

93928 of 173072 branches covered (54.27%)

38 of 39 new or added lines in 3 files covered. (97.44%)

104 existing lines in 21 files now uncovered.

238407 of 262133 relevant lines covered (90.95%)

5612447.62 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.56

/src/realm/object-store/c_api/logging.cpp

////////////////////////////////////////////////////////////////////////////
//
// Copyright 2021 Realm Inc.
//
// 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 utilied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
////////////////////////////////////////////////////////////////////////////

#include "types.hpp"
#include "util.hpp"

namespace realm::c_api {
namespace {
using Logger = realm::util::Logger;

static_assert(realm_log_level_e(Logger::Level::all) == RLM_LOG_LEVEL_ALL);
static_assert(realm_log_level_e(Logger::Level::trace) == RLM_LOG_LEVEL_TRACE);
static_assert(realm_log_level_e(Logger::Level::debug) == RLM_LOG_LEVEL_DEBUG);
static_assert(realm_log_level_e(Logger::Level::detail) == RLM_LOG_LEVEL_DETAIL);
static_assert(realm_log_level_e(Logger::Level::info) == RLM_LOG_LEVEL_INFO);
static_assert(realm_log_level_e(Logger::Level::warn) == RLM_LOG_LEVEL_WARNING);
static_assert(realm_log_level_e(Logger::Level::error) == RLM_LOG_LEVEL_ERROR);
static_assert(realm_log_level_e(Logger::Level::fatal) == RLM_LOG_LEVEL_FATAL);
static_assert(realm_log_level_e(Logger::Level::off) == RLM_LOG_LEVEL_OFF);

class CLogger : public realm::util::Logger {
public:
    CLogger(UserdataPtr userdata, realm_log_func_t log_callback, Logger::Level level)
        : Logger()
        , m_userdata(std::move(userdata))
        , m_log_callback(log_callback)
    {
        set_level_threshold(level);
    }

protected:
    void do_log(const util::LogCategory&, Logger::Level level, const std::string& message) final
    {

        // FIXME use category
        m_log_callback(m_userdata.get(), realm_log_level_e(level), message.c_str());
    }

private:
    UserdataPtr m_userdata;
    realm_log_func_t m_log_callback;
};
} // namespace

RLM_API void realm_set_log_callback(realm_log_func_t callback, realm_log_level_e level, realm_userdata_t userdata,
                                    realm_free_userdata_func_t userdata_free) noexcept
{
    std::shared_ptr<util::Logger> logger;
    if (callback) {
        logger = std::make_shared<CLogger>(UserdataPtr{userdata, userdata_free}, callback,
                                           realm::util::Logger::Level(level));
    }
    util::Logger::set_default_logger(std::move(logger));
}

RLM_API void realm_set_log_level(realm_log_level_e level) noexcept
{
    util::LogCategory::realm.set_default_level_threshold(realm::util::LogCategory::Level(level));
}

RLM_API realm_log_level_e realm_set_log_level_category(const char* category_name, realm_log_level_e level) noexcept
{
    auto& cat = util::LogCategory::get_category(category_name);
    realm_log_level_e prev_level = realm_log_level_e(util::Logger::get_default_logger()->get_level_threshold(cat));
    cat.set_default_level_threshold(realm::util::LogCategory::Level(level));
    return prev_level;
}

RLM_API realm_log_level_e realm_get_log_level_category(const char* category_name) noexcept
{
    auto& cat = util::LogCategory::get_category(category_name);
    return realm_log_level_e(util::Logger::get_default_logger()->get_level_threshold(cat));
}

RLM_API size_t realm_get_category_names(size_t num_values, const char** out_values)
{
    auto vec = util::LogCategory::get_category_names();
    auto number_to_copy = vec.size();
    if (num_values > 0) {
        if (number_to_copy > num_values)
            number_to_copy = num_values;
        for (size_t n = 0; n < number_to_copy; n++) {
            out_values[n] = vec[n];
        }
    }
    return number_to_copy;
}

} // namespace realm::c_api

1	////////////////////////////////////////////////////////////////////////////
2	//
3	// Copyright 2021 Realm Inc.
4	//
5	// Licensed under the Apache License, Version 2.0 (the "License");
6	// you may not use this file except in compliance with the License.
7	// You may obtain a copy of the License at
8	//
9	// http://www.apache.org/licenses/LICENSE-2.0
10	//
11	// Unless required by applicable law or agreed to in writing, software
12	// distributed under the License is distributed on an "AS IS" BASIS,
13	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or utilied.
14	// See the License for the specific language governing permissions and
15	// limitations under the License.
16	//
17	////////////////////////////////////////////////////////////////////////////
18
19	#include "types.hpp"
20	#include "util.hpp"
21
22	namespace realm::c_api {
23	namespace {
24	using Logger = realm::util::Logger;
25
26	static_assert(realm_log_level_e(Logger::Level::all) == RLM_LOG_LEVEL_ALL);
27	static_assert(realm_log_level_e(Logger::Level::trace) == RLM_LOG_LEVEL_TRACE);
28	static_assert(realm_log_level_e(Logger::Level::debug) == RLM_LOG_LEVEL_DEBUG);
29	static_assert(realm_log_level_e(Logger::Level::detail) == RLM_LOG_LEVEL_DETAIL);
30	static_assert(realm_log_level_e(Logger::Level::info) == RLM_LOG_LEVEL_INFO);
31	static_assert(realm_log_level_e(Logger::Level::warn) == RLM_LOG_LEVEL_WARNING);
32	static_assert(realm_log_level_e(Logger::Level::error) == RLM_LOG_LEVEL_ERROR);
33	static_assert(realm_log_level_e(Logger::Level::fatal) == RLM_LOG_LEVEL_FATAL);
34	static_assert(realm_log_level_e(Logger::Level::off) == RLM_LOG_LEVEL_OFF);
35
36	class CLogger : public realm::util::Logger {
37	public:
38	CLogger(UserdataPtr userdata, realm_log_func_t log_callback, Logger::Level level)
39	: Logger()
40	, m_userdata(std::move(userdata))
41	, m_log_callback(log_callback)
42	{	2✔
43	set_level_threshold(level);	2✔
44	}	2✔
45
46	protected:
47	void do_log(const util::LogCategory&, Logger::Level level, const std::string& message) final
48	{	22✔
49		11✔
50	// FIXME use category	11✔
51	m_log_callback(m_userdata.get(), realm_log_level_e(level), message.c_str());	22✔
52	}	22✔
53
54	private:
55	UserdataPtr m_userdata;
56	realm_log_func_t m_log_callback;
57	};
58	} // namespace
59
60	RLM_API void realm_set_log_callback(realm_log_func_t callback, realm_log_level_e level, realm_userdata_t userdata,
61	realm_free_userdata_func_t userdata_free) noexcept
62	{	4✔
63	std::shared_ptr<util::Logger> logger;	4✔
64	if (callback) {	4✔
65	logger = std::make_shared<CLogger>(UserdataPtr{userdata, userdata_free}, callback,	2✔
66	realm::util::Logger::Level(level));	2✔
67	}	2✔
68	util::Logger::set_default_logger(std::move(logger));	4✔
69	}	4✔
70
71	RLM_API void realm_set_log_level(realm_log_level_e level) noexcept
72	{	6✔
73	util::LogCategory::realm.set_default_level_threshold(realm::util::LogCategory::Level(level));	6✔
74	}	6✔
75
76	RLM_API realm_log_level_e realm_set_log_level_category(const char* category_name, realm_log_level_e level) noexcept
77	{	2✔
78	auto& cat = util::LogCategory::get_category(category_name);	2✔
79	realm_log_level_e prev_level = realm_log_level_e(util::Logger::get_default_logger()->get_level_threshold(cat));	2✔
80	cat.set_default_level_threshold(realm::util::LogCategory::Level(level));	2✔
81	return prev_level;	2✔
82	}	2✔
83
84	RLM_API realm_log_level_e realm_get_log_level_category(const char* category_name) noexcept
85	{	34✔
86	auto& cat = util::LogCategory::get_category(category_name);	34✔
87	return realm_log_level_e(util::Logger::get_default_logger()->get_level_threshold(cat));	34✔
88	}	34✔
89
90	RLM_API size_t realm_get_category_names(size_t num_values, const char** out_values)
91	{	2✔
92	auto vec = util::LogCategory::get_category_names();	2✔
93	auto number_to_copy = vec.size();	2✔
94	if (num_values > 0) {	2✔
95	if (number_to_copy > num_values)	2✔
NEW 96	number_to_copy = num_values;	×
97	for (size_t n = 0; n < number_to_copy; n++) {	32✔
98	out_values[n] = vec[n];	30✔
99	}	30✔
100	}	2✔
101	return number_to_copy;	2✔
102	}	2✔
103
104	} // namespace realm::c_api

realm / realm-core / 2103

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous