github_pull_request_281750

Committed 30 Oct 2023 03:37PM UTC coverage: 90.528% (-1.0%) from 91.571%

Build # github_pull_request_281750

Build Type

Pull #6073

Evergreen

Committed by

jedelbo

Commit Message

Log free space and history sizes when opening file

Pull Request Pull Request #6073: Merge next-major

Run Details

95488 of 175952 branches covered (0.0%)

8973 of 12277 new or added lines in 149 files covered. (73.09%)

622 existing lines in 51 files now uncovered.

233503 of 257934 relevant lines covered (90.53%)

6533720.56 hits per line

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

89.19

/src/realm/util/logger.cpp

/*************************************************************************
 *
 * Copyright 2016 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 implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **************************************************************************/

#include <realm/util/logger.hpp>

#include <iostream>
#include <mutex>
#include <map>

namespace realm::util {

namespace {
auto& s_logger_mutex = *new std::mutex;
std::shared_ptr<util::Logger> s_default_logger;
} // anonymous namespace

size_t LogCategory::s_next_index = 0;
static std::map<std::string_view, LogCategory*> log_catagory_map;

LogCategory LogCategory::realm("Realm", nullptr);
LogCategory LogCategory::storage("Storage", &realm);
LogCategory LogCategory::transaction("Transaction", &storage);
LogCategory LogCategory::query("Query", &storage);
LogCategory LogCategory::object("Object", &storage);
LogCategory LogCategory::notification("Notification", &storage);
LogCategory LogCategory::sync("Sync", &realm);
LogCategory LogCategory::client("Client", &sync);
LogCategory LogCategory::session("Session", &client);
LogCategory LogCategory::changeset("Changeset", &client);
LogCategory LogCategory::network("Network", &client);
LogCategory LogCategory::reset("Reset", &client);
LogCategory LogCategory::server("Server", &sync);
LogCategory LogCategory::app("App", &realm);
LogCategory LogCategory::sdk("SDK", &realm);


LogCategory::LogCategory(std::string_view name, LogCategory* parent)
    : m_index(s_next_index++)
    , m_default_level(Logger::Level::info)
{
    if (parent) {
        m_name = parent->get_name() + ".";
        parent->m_children.push_back(this);
    }
    m_name += name;
    log_catagory_map.emplace(m_name, this);
}

LogCategory& LogCategory::get_category(std::string_view name)
{
    return *log_catagory_map.at(name); // Throws
}

void LogCategory::set_default_level_threshold(Level level)
{
    m_default_level.store(level);
    for (auto c : m_children) {
        c->set_default_level_threshold(level);
    }
    std::lock_guard lock(s_logger_mutex);
    if (s_default_logger)
        set_default_level_threshold(s_default_logger.get());
}

LogCategory::Level LogCategory::get_default_level_threshold() const noexcept
{
    return m_default_level.load(std::memory_order_relaxed);
}

void LogCategory::set_level_threshold(Logger* root, Level level) const
{
    root->set_level_threshold(m_index, level);
    for (auto c : m_children) {
        c->set_level_threshold(root, level);
    }
}

void LogCategory::set_default_level_threshold(Logger* root) const
{
    root->set_level_threshold(m_index, m_default_level.load(std::memory_order_relaxed));
    for (auto c : m_children) {
        c->set_default_level_threshold(root);
    }
}

void Logger::set_default_logger(std::shared_ptr<util::Logger> logger) noexcept
{
    std::lock_guard lock(s_logger_mutex);
    s_default_logger = logger;
}

std::shared_ptr<util::Logger>& Logger::get_default_logger() noexcept
{
    std::lock_guard lock(s_logger_mutex);
    if (!s_default_logger) {
        s_default_logger = std::make_shared<StderrLogger>();
    }

    return s_default_logger;
}

const char* Logger::get_level_prefix(Level level) noexcept
{
    switch (level) {
        case Level::off:
            [[fallthrough]];
        case Level::all:
            [[fallthrough]];
        case Level::trace:
            [[fallthrough]];
        case Level::debug:
            [[fallthrough]];
        case Level::detail:
            [[fallthrough]];
        case Level::info:
            break;
        case Level::warn:
            return "WARNING: ";
        case Level::error:
            return "ERROR: ";
        case Level::fatal:
            return "FATAL: ";
    }
    return "";
}

const std::string_view Logger::level_to_string(Level level) noexcept
{
    switch (level) {
        case Logger::Level::all:
            return "all";
        case Logger::Level::trace:
            return "trace";
        case Logger::Level::debug:
            return "debug";
        case Logger::Level::detail:
            return "detail";
        case Logger::Level::info:
            return "info";
        case Logger::Level::warn:
            return "warn";
        case Logger::Level::error:
            return "error";
        case Logger::Level::fatal:
            return "fatal";
        case Logger::Level::off:
            return "off";
    }
    REALM_ASSERT(false);
    return "";
}

void StderrLogger::do_log(const LogCategory& cat, Level level, const std::string& message)
{
    // std::cerr is unbuffered, so no need to flush
    std::cerr << cat.get_name() << " - " << get_level_prefix(level) << message << '\n'; // Throws
}

void StreamLogger::do_log(const LogCategory&, Level level, const std::string& message)
{
    m_out << get_level_prefix(level) << message << std::endl; // Throws
}

void ThreadSafeLogger::do_log(const LogCategory& category, Level level, const std::string& message)
{
    LockGuard l(m_mutex);
    Logger::do_log(*m_base_logger_ptr, category, level, message); // Throws
}

void PrefixLogger::do_log(const LogCategory& category, Level level, const std::string& message)
{
    Logger::do_log(m_chained_logger, category, level, m_prefix + message); // Throws
}

void LocalThresholdLogger::do_log(const LogCategory& category, Logger::Level level, std::string const& message)
{
    Logger::do_log(*m_chained_logger, category, level, message); // Throws
}
} // namespace realm::util

1	/*************************************************************************
2	*
3	* Copyright 2016 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 implied.
14	* See the License for the specific language governing permissions and
15	* limitations under the License.
16	*
17	**************************************************************************/
18
19	#include <realm/util/logger.hpp>
20
21	#include <iostream>
22	#include <mutex>
23	#include <map>
24
25	namespace realm::util {
26
27	namespace {
28	auto& s_logger_mutex = *new std::mutex;
29	std::shared_ptr<util::Logger> s_default_logger;
30	} // anonymous namespace
31
32	size_t LogCategory::s_next_index = 0;
33	static std::map<std::string_view, LogCategory*> log_catagory_map;
34
35	LogCategory LogCategory::realm("Realm", nullptr);
36	LogCategory LogCategory::storage("Storage", &realm);
37	LogCategory LogCategory::transaction("Transaction", &storage);
38	LogCategory LogCategory::query("Query", &storage);
39	LogCategory LogCategory::object("Object", &storage);
40	LogCategory LogCategory::notification("Notification", &storage);
41	LogCategory LogCategory::sync("Sync", &realm);
42	LogCategory LogCategory::client("Client", &sync);
43	LogCategory LogCategory::session("Session", &client);
44	LogCategory LogCategory::changeset("Changeset", &client);
45	LogCategory LogCategory::network("Network", &client);
46	LogCategory LogCategory::reset("Reset", &client);
47	LogCategory LogCategory::server("Server", &sync);
48	LogCategory LogCategory::app("App", &realm);
49	LogCategory LogCategory::sdk("SDK", &realm);
50
51
52	LogCategory::LogCategory(std::string_view name, LogCategory* parent)
53	: m_index(s_next_index++)
54	, m_default_level(Logger::Level::info)
55	{	360✔
56	if (parent) {	360✔
57	m_name = parent->get_name() + ".";	336✔
58	parent->m_children.push_back(this);	336✔
59	}	336✔
60	m_name += name;	360✔
61	log_catagory_map.emplace(m_name, this);	360✔
62	}	360✔
63
64	LogCategory& LogCategory::get_category(std::string_view name)
65	{	194,097✔
66	return *log_catagory_map.at(name); // Throws	194,097✔
67	}	194,097✔
68
69	void LogCategory::set_default_level_threshold(Level level)
70	{	1,358,745✔
71	m_default_level.store(level);	1,358,745✔
72	for (auto c : m_children) {	1,261,029✔
73	c->set_default_level_threshold(level);	1,164,654✔
74	}	1,164,654✔
75	std::lock_guard lock(s_logger_mutex);	1,358,745✔
76	if (s_default_logger)	1,358,745✔
77	set_default_level_threshold(s_default_logger.get());	1,358,403✔
78	}	1,358,745✔
79
80	LogCategory::Level LogCategory::get_default_level_threshold() const noexcept
81	{	24✔
82	return m_default_level.load(std::memory_order_relaxed);	24✔
83	}	24✔
84
85	void LogCategory::set_level_threshold(Logger* root, Level level) const
86	{	1,058,811✔
87	root->set_level_threshold(m_index, level);	1,058,811✔
88	for (auto c : m_children) {	1,023,996✔
89	c->set_level_threshold(root, level);	988,206✔
90	}	988,206✔
91	}	1,058,811✔
92
93	void LogCategory::set_default_level_threshold(Logger* root) const
94	{	4,532,052✔
95	root->set_level_threshold(m_index, m_default_level.load(std::memory_order_relaxed));	4,532,052✔
96	for (auto c : m_children) {	3,811,938✔
97	c->set_default_level_threshold(root);	3,100,077✔
98	}	3,100,077✔
99	}	4,532,052✔
100
101	void Logger::set_default_logger(std::shared_ptr<util::Logger> logger) noexcept
102	{	12✔
103	std::lock_guard lock(s_logger_mutex);	12✔
104	s_default_logger = logger;	12✔
105	}	12✔
106
107	std::shared_ptr<util::Logger>& Logger::get_default_logger() noexcept
108	{	185,343✔
109	std::lock_guard lock(s_logger_mutex);	185,343✔
110	if (!s_default_logger) {	185,343✔
111	s_default_logger = std::make_shared<StderrLogger>();	30✔
112	}	30✔
113		91,470✔
114	return s_default_logger;	185,343✔
115	}	185,343✔
116
117	const char* Logger::get_level_prefix(Level level) noexcept
118	{	936,654✔
119	switch (level) {	936,654✔
120	case Level::off:	✔
121	[[fallthrough]];	×
122	case Level::all:	✔
123	[[fallthrough]];	×
124	case Level::trace:	90,636✔
125	[[fallthrough]];	90,636✔
126	case Level::debug:	764,274✔
127	[[fallthrough]];	764,274✔
128	case Level::detail:	848,775✔
129	[[fallthrough]];	848,775✔
130	case Level::info:	935,508✔
131	break;	935,508✔
132	case Level::warn:	418,467✔
133	return "WARNING: ";	708✔
134	case Level::error:	418,353✔
135	return "ERROR: ";	471✔
136	case Level::fatal:	418,113✔
137	return "FATAL: ";	×
138	}	935,472✔
139	return "";	935,472✔
140	}	935,472✔
141
142	const std::string_view Logger::level_to_string(Level level) noexcept
143	{	20,844✔
144	switch (level) {	20,844✔
145	case Logger::Level::all:	6✔
146	return "all";	6✔
147	case Logger::Level::trace:	6✔
148	return "trace";	6✔
149	case Logger::Level::debug:	5,991✔
150	return "debug";	5,991✔
151	case Logger::Level::detail:	6✔
152	return "detail";	6✔
153	case Logger::Level::info:	2,865✔
154	return "info";	2,865✔
155	case Logger::Level::warn:	6✔
156	return "warn";	6✔
157	case Logger::Level::error:	6✔
158	return "error";	6✔
159	case Logger::Level::fatal:	6✔
160	return "fatal";	6✔
161	case Logger::Level::off:	11,952✔
162	return "off";	11,952✔
163	}	×
164	REALM_ASSERT(false);	×
165	return "";	×
166	}	×
167
168	void StderrLogger::do_log(const LogCategory& cat, Level level, const std::string& message)
169	{	629,409✔
170	// std::cerr is unbuffered, so no need to flush	307,512✔
171	std::cerr << cat.get_name() << " - " << get_level_prefix(level) << message << '\n'; // Throws	629,409✔
172	}	629,409✔
173
174	void StreamLogger::do_log(const LogCategory&, Level level, const std::string& message)
175	{	307,242✔
176	m_out << get_level_prefix(level) << message << std::endl; // Throws	307,242✔
177	}	307,242✔
178
179	void ThreadSafeLogger::do_log(const LogCategory& category, Level level, const std::string& message)
180	{	483,171✔
181	LockGuard l(m_mutex);	483,171✔
182	Logger::do_log(*m_base_logger_ptr, category, level, message); // Throws	483,171✔
183	}	483,171✔
184
185	void PrefixLogger::do_log(const LogCategory& category, Level level, const std::string& message)
186	{	387,951✔
187	Logger::do_log(m_chained_logger, category, level, m_prefix + message); // Throws	387,951✔
188	}	387,951✔
189
190	void LocalThresholdLogger::do_log(const LogCategory& category, Logger::Level level, std::string const& message)
191	{	×
NEW 192	Logger::do_log(*m_chained_logger, category, level, message); // Throws	×
193	}	×
194	} // namespace realm::util

realm / realm-core / github_pull_request_281750

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