1787

Committed 28 Oct 2023 12:35PM UTC coverage: 91.591% (+0.009%) from 91.582%

Build # 1787

Build Type

push

Evergreen

Committed by

web-flow

Commit Message

Improve configurations for sanitized builds (#6911)

* Refactor sanitizer flags for different build types:

** Enable address sanitizer for msvc
** Allow to build with sanitizer for diffent optimized build (also Debug)
** Make RelASAN, RelTSAN, RelUSAN, RelUSAN just shortcuts for half-optimized builds

* Fix usage of moved object for fuzz tester
* Check asan/tsan on macos x64/arm64
* Check asan with msvc 2019
* Remove Jenkins sanitized builders replaced by evergreen configs
* Work-around stack-use-after-scope with msvc2019 and mpark
* Fix crash on check with staled ColKeys
* fix a buffer overrun in a test
* fix a race in async_open_realm test util
* Add some logger related test fixes
* Work around catch2 limmitation with not thread safe asserts and TSAN races
* Run multiprocesses tests under sanitizers
* add assert for an error reported by undefined sanitizer
* Workaround uv scheduler main thread only constraint for callbacks called from non main thread and requesting a realm

---------

Co-authored-by: James Stone <james.stone@mongodb.com>

Run Details

94356 of 173648 branches covered (0.0%)

54 of 63 new or added lines in 15 files covered. (85.71%)

2202 existing lines in 52 files now uncovered.

230692 of 251872 relevant lines covered (91.59%)

7167285.55 hits per line

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

86.36

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

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(Level level, const std::string& message)
{
    static Mutex mutex;
    LockGuard l(mutex);
    // 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	{	12✔
34	std::lock_guard lock(s_logger_mutex);	12✔
35	s_default_logger = logger;	12✔
36	}	12✔
37
38	std::shared_ptr<util::Logger>& Logger::get_default_logger() noexcept
39	{	185,004✔
40	std::lock_guard lock(s_logger_mutex);	185,004✔
41	if (!s_default_logger) {	185,004✔
42	s_default_logger = std::make_shared<StderrLogger>();	30✔
43	s_default_logger->set_level_threshold(s_default_level);	30✔
44	}	30✔
45		91,377✔
46	return s_default_logger;	185,004✔
47	}	185,004✔
48
49	void Logger::set_default_level_threshold(Level level) noexcept
50	{	38,979✔
51	std::lock_guard lock(s_logger_mutex);	38,979✔
52	s_default_level = level;	38,979✔
53	if (s_default_logger)	38,979✔
54	s_default_logger->set_level_threshold(level);	38,964✔
55	}	38,979✔
56
57	Logger::Level Logger::get_default_level_threshold() noexcept
58	{	534✔
59	return s_default_level.load(std::memory_order_relaxed);	534✔
60	}	534✔
61
62	const char* Logger::get_level_prefix(Level level) noexcept
63	{	2,258,670✔
64	switch (level) {	2,258,670✔
65	case Level::off:	✔
66	[[fallthrough]];	×
67	case Level::all:	✔
68	[[fallthrough]];	×
69	case Level::trace:	89,937✔
70	[[fallthrough]];	89,937✔
71	case Level::debug:	1,583,112✔
72	[[fallthrough]];	1,583,112✔
73	case Level::detail:	1,927,833✔
74	[[fallthrough]];	1,927,833✔
75	case Level::info:	2,235,672✔
76	break;	2,235,672✔
77	case Level::warn:	947,082✔
78	return "WARNING: ";	22,572✔
79	case Level::error:	935,877✔
80	return "ERROR: ";	477✔
81	case Level::fatal:	935,634✔
82	return "FATAL: ";	×
83	}	2,235,570✔
84	return "";	2,235,570✔
85	}	2,235,570✔
86
87	const std::string_view Logger::level_to_string(Level level) noexcept
88	{	20,658✔
89	switch (level) {	20,658✔
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:	16,770✔
95	return "debug";	16,770✔
96	case Logger::Level::detail:	6✔
97	return "detail";	6✔
98	case Logger::Level::info:	2,808✔
99	return "info";	2,808✔
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,044✔
107	return "off";	1,044✔
108	}	×
109	REALM_ASSERT(false);	×
110	return "";	×
111	}	×
112
113	void StderrLogger::do_log(Level level, const std::string& message)
114	{	2,120,145✔
115	static Mutex mutex;	2,120,145✔
116	LockGuard l(mutex);	2,120,145✔
117	// std::cerr is unbuffered, so no need to flush	1,027,683✔
118	std::cerr << get_level_prefix(level) << message << '\n'; // Throws	2,120,145✔
119	}	2,120,145✔
120
121	void StreamLogger::do_log(Level level, const std::string& message)
122	{	138,501✔
123	m_out << get_level_prefix(level) << message << std::endl; // Throws	138,501✔
124	}	138,501✔
125
126	void ThreadSafeLogger::do_log(Level level, const std::string& message)
127	{	476,844✔
128	LockGuard l(m_mutex);	476,844✔
129	Logger::do_log(*m_base_logger_ptr, level, message); // Throws	476,844✔
130	}	476,844✔
131
132	void PrefixLogger::do_log(Level level, const std::string& message)
133	{	454,599✔
134	Logger::do_log(m_chained_logger, level, m_prefix + message); // Throws	454,599✔
135	}	454,599✔
136
137	void LocalThresholdLogger::do_log(Logger::Level level, std::string const& message)
UNCOV 138	{	×
UNCOV 139	Logger::do_log(*m_chained_logger, level, message); // Throws	×
UNCOV 140	}	×
141	} // namespace realm::util

realm / realm-core / 1787

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