github_pull_request_278228

Committed 04 Oct 2023 10:15PM UTC coverage: 91.582% (+0.007%) from 91.575%

Build # github_pull_request_278228

Build Type

Pull #7029

Evergreen

Committed by

tgoyne

Commit Message

Use UNITTEST_LOG_LEVEL in objectstore tests

For historical reasons core and sync tests use the UNITTEST_LOG_LEVEL
environment variable to determine the test log level, while object store tests
used a build time setting. This brings them into alignment on using the env
variable, and applies it via setting the default log level on startup in a
single place.

Pull Request Pull Request #7029: Use UNITTEST_LOG_LEVEL in objectstore tests

Run Details

94218 of 173442 branches covered (0.0%)

46 of 54 new or added lines in 5 files covered. (85.19%)

51 existing lines in 12 files now uncovered.

230351 of 251523 relevant lines covered (91.58%)

6704577.96 hits per line

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

87.93

/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>

namespace realm::util {

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

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>();
        s_default_logger->set_level_threshold(s_default_level);
    }

    return s_default_logger;
}

void Logger::set_default_level_threshold(Level level) noexcept
{
    std::lock_guard lock(s_logger_mutex);
    s_default_level = level;
    if (s_default_logger)
        s_default_logger->set_level_threshold(level);
}

Logger::Level Logger::get_default_level_threshold() noexcept
{
    return s_default_level.load(std::memory_order_relaxed);
}

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 "";
}

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 "";
}

std::optional<Logger::Level> Logger::level_from_string(std::string_view str)
{
    if (str == "all") {
        return Logger::Level::all;
    }
    if (str == "trace") {
        return Logger::Level::trace;
    }
    if (str == "debug") {
        return Logger::Level::debug;
    }
    if (str == "detail") {
        return Logger::Level::detail;
    }
    if (str == "info") {
        return Logger::Level::info;
    }
    if (str == "warn") {
        return Logger::Level::warn;
    }
    if (str == "error") {
        return Logger::Level::error;
    }
    if (str == "fatal") {
        return Logger::Level::fatal;
    }
    if (str == "off") {
        return Logger::Level::off;
    }
    return std::nullopt;
}

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

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

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

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

void LocalThresholdLogger::do_log(Logger::Level level, std::string const& message)
{
    Logger::do_log(*m_chained_logger, 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
24	namespace realm::util {
25
26	namespace {
27	auto& s_logger_mutex = *new std::mutex;
28	std::shared_ptr<util::Logger> s_default_logger;
29	std::atomic<Logger::Level> s_default_level = Logger::Level::info;
30	} // anonymous namespace
31
32	void Logger::set_default_logger(std::shared_ptr<util::Logger> logger) noexcept
33	{	36✔
34	std::lock_guard lock(s_logger_mutex);	36✔
35	s_default_logger = logger;	36✔
36	}	36✔
37
38	std::shared_ptr<util::Logger>& Logger::get_default_logger() noexcept
39	{	185,037✔
40	std::lock_guard lock(s_logger_mutex);	185,037✔
41	if (!s_default_logger) {	185,037✔
42	s_default_logger = std::make_shared<StderrLogger>();	6✔
43	s_default_logger->set_level_threshold(s_default_level);	6✔
44	}	6✔
45		91,317✔
46	return s_default_logger;	185,037✔
47	}	185,037✔
48
49	void Logger::set_default_level_threshold(Level level) noexcept
50	{	24✔
51	std::lock_guard lock(s_logger_mutex);	24✔
52	s_default_level = level;	24✔
53	if (s_default_logger)	24✔
54	s_default_logger->set_level_threshold(level);	18✔
55	}	24✔
56
57	Logger::Level Logger::get_default_level_threshold() noexcept
58	{	510✔
59	return s_default_level.load(std::memory_order_relaxed);	510✔
60	}	510✔
61
62	const char* Logger::get_level_prefix(Level level) noexcept
63	{	847,194✔
64	switch (level) {	847,194✔
65	case Level::off:	✔
66	[[fallthrough]];	×
67	case Level::all:	✔
68	[[fallthrough]];	×
69	case Level::trace:	90,114✔
70	[[fallthrough]];	90,114✔
71	case Level::debug:	442,491✔
72	[[fallthrough]];	442,491✔
73	case Level::detail:	548,070✔
74	[[fallthrough]];	548,070✔
75	case Level::info:	824,781✔
76	break;	824,781✔
77	case Level::warn:	490,005✔
78	return "WARNING: ";	22,194✔
79	case Level::error:	478,938✔
80	return "ERROR: ";	267✔
81	case Level::fatal:	478,911✔
82	return "FATAL: ";	×
83	}	824,724✔
84	return "";	824,724✔
85	}	824,724✔
86
87	std::string_view Logger::level_to_string(Level level) noexcept
88	{	21,339✔
89	switch (level) {	21,339✔
90	case Logger::Level::all:	6✔
91	return "all";	6✔
92	case Logger::Level::trace:	6✔
93	return "trace";	6✔
94	case Logger::Level::debug:	6,555✔
95	return "debug";	6,555✔
96	case Logger::Level::detail:	6✔
97	return "detail";	6✔
98	case Logger::Level::info:	13,551✔
99	return "info";	13,551✔
100	case Logger::Level::warn:	6✔
101	return "warn";	6✔
102	case Logger::Level::error:	6✔
103	return "error";	6✔
104	case Logger::Level::fatal:	6✔
105	return "fatal";	6✔
106	case Logger::Level::off:	1,197✔
107	return "off";	1,197✔
108	}	×
109	REALM_ASSERT(false);	×
110	return "";	×
111	}	×
112
113	std::optional<Logger::Level> Logger::level_from_string(std::string_view str)
114	{	66✔
115	if (str == "all") {	66✔
116	return Logger::Level::all;	6✔
117	}	6✔
118	if (str == "trace") {	60✔
119	return Logger::Level::trace;	6✔
120	}	6✔
121	if (str == "debug") {	54✔
122	return Logger::Level::debug;	18✔
123	}	18✔
124	if (str == "detail") {	36✔
125	return Logger::Level::detail;	6✔
126	}	6✔
127	if (str == "info") {	30✔
128	return Logger::Level::info;	6✔
129	}	6✔
130	if (str == "warn") {	24✔
131	return Logger::Level::warn;	6✔
132	}	6✔
133	if (str == "error") {	18✔
134	return Logger::Level::error;	6✔
135	}	6✔
136	if (str == "fatal") {	12✔
137	return Logger::Level::fatal;	6✔
138	}	6✔
139	if (str == "off") {	6✔
140	return Logger::Level::off;	6✔
141	}	6✔
NEW 142	return std::nullopt;	×
NEW 143	}	×
144
145	void StderrLogger::do_log(Level level, const std::string& message)
146	{	708,519✔
147	// std::cerr is unbuffered, so no need to flush	565,002✔
148	std::cerr << get_level_prefix(level) << message << '\n'; // Throws	708,519✔
149	}	708,519✔
150
151	void StreamLogger::do_log(Level level, const std::string& message)
152	{	138,669✔
153	m_out << get_level_prefix(level) << message << std::endl; // Throws	138,669✔
154	}	138,669✔
155
156	void ThreadSafeLogger::do_log(Level level, const std::string& message)
157	{	479,139✔
158	LockGuard l(m_mutex);	479,139✔
159	Logger::do_log(*m_base_logger_ptr, level, message); // Throws	479,139✔
160	}	479,139✔
161
162	void PrefixLogger::do_log(Level level, const std::string& message)
163	{	195,375✔
164	Logger::do_log(m_chained_logger, level, m_prefix + message); // Throws	195,375✔
165	}	195,375✔
166
167	void LocalThresholdLogger::do_log(Logger::Level level, std::string const& message)
168	{	×
169	Logger::do_log(*m_chained_logger, level, message); // Throws	×
170	}	×
171	} // namespace realm::util

realm / realm-core / github_pull_request_278228

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