logger Namespace Reference

Namespaces
	anonymous_namespace{Logger.cpp}

Classes
class	Collector
struct	DebugTimerParams
class	Duration
class	DurationTree
struct	GetDepth
class	JsonEncoder
struct	EraseDurationTrees
	Depth-first search and erase all DurationTrees. Not thread-safe. More...
struct	ThreadLocalIds
class	LocalIdsScopeGuard
class	LogOptions
struct	LogShutdown
class	Logger
class	DebugTimer

Typedefs
using	ChannelLogger = boost::log::sources::channel_logger_mt< Channel >
using	SeverityLogger = boost::log::sources::severity_logger_mt< Severity >
using	ClogSync = sinks::synchronous_sink< sinks::text_ostream_backend >
using	FileSync = sinks::synchronous_sink< sinks::text_file_backend >
using	Clock = std::chrono::steady_clock
using	DurationTreeNode = boost::variant< Duration, DurationTree & >
using	DurationTreeNodes = std::deque< DurationTreeNode >
using	DurationTreeMap = std::unordered_map< ThreadId, std::unique_ptr< DurationTree >>
using	RequestId = uint64_t
using	ThreadId = uint64_t
using	Channels = std::set< Channel >
using	FatalFunc = void(*)() noexcept

Enumerations
enum	Channel { IR = 0, PTX, ASM, _NCHANNELS }
enum	Severity {   DEBUG4 = 0, DEBUG3, DEBUG2, DEBUG1,   INFO, WARNING, ERROR, FATAL,   _NSEVERITIES }

Functions
	BOOST_LOG_GLOBAL_LOGGER_CTOR_ARGS (gChannelLogger_IR, ChannelLogger,(keywords::channel=IR)) BOOST_LOG_GLOBAL_LOGGER_CTOR_ARGS(gChannelLogger_PTX
boost::log::formatting_ostream &	operator<< (boost::log::formatting_ostream &strm, boost::log::to_log_manip< Channel, tag::channel > const &manip)
boost::log::formatting_ostream &	operator<< (boost::log::formatting_ostream &strm, boost::log::to_log_manip< Severity, tag::severity > const &manip)
template<typename TAG , typename SINK >
void	set_formatter (SINK &sink)
template<typename FILE_SINK , typename TAG >
boost::shared_ptr< FILE_SINK >	make_sink (boost::shared_ptr< Collector > &collector, LogOptions const &log_opts, fs::path const &full_log_dir, TAG const tag)
template<typename CONSOLE_SINK >
boost::shared_ptr< CONSOLE_SINK >	make_sink (LogOptions const &log_opts)
void	init (LogOptions const &log_opts)
void	set_once_fatal_func (FatalFunc fatal_func)
void	shutdown ()
std::istream &	operator>> (std::istream &in, Channels &channels)
std::ostream &	operator<< (std::ostream &out, Channels const &channels)
std::istream &	operator>> (std::istream &in, Severity &sev)
std::ostream &	operator<< (std::ostream &out, Severity const &sev)
Duration *	newDuration (DebugTimerParams const debug_timer_params)
std::ostream &	operator<< (std::ostream &os, Duration const &duration)
std::ostream &	operator<< (std::ostream &os, DurationTree const &duration_tree)
boost::log::record_ostream &	operator<< (boost::log::record_ostream &os, DurationTreeMap::const_reference kv_pair)
void	logAndEraseDurationTree (std::string *json_str)
void	debug_timer_new_thread (ThreadId const parent_thread_id)
RequestId	request_id ()
ThreadId	thread_id ()
ThreadLocalIds	thread_local_ids ()
RequestId	set_new_request_id ()
void	set_request_id (RequestId const request_id)
fs::path	get_log_dir_path ()
bool	fast_logging_check (Channel)
bool	fast_logging_check (Severity severity)
template<typename X , typename Y >
BOOST_NOINLINE std::string *	check_failed (X const &x, Y const &y, char const *xstr, char const *ystr, char const *op_str)

Variables
std::atomic< FatalFunc >	g_fatal_func {nullptr}
std::once_flag	g_fatal_func_flag
bool	g_any_active_channels {false}
Severity	g_min_active_severity {Severity::FATAL}
static fs::path	g_log_dir_path
std::mutex	g_duration_tree_map_mutex
DurationTreeMap	g_duration_tree_map
constexpr std::array< char const *, 3 >	ChannelNames {"IR", "PTX", "ASM"}
constexpr std::array< char, 3 >	ChannelSymbols {'R', 'P', 'A'}
constexpr std::array< char const *, 8 >	SeverityNames
constexpr std::array< char, 8 >	SeveritySymbols {'4', '3', '2', '1', 'I', 'W', 'E', 'F'}

Typedef Documentation

logger::ChannelLogger

Definition at line 53 of file Logger.cpp.

using logger::Channels = typedef std::set<Channel>

Definition at line 199 of file Logger.h.

using logger::Clock = typedef std::chrono::steady_clock

Definition at line 555 of file Logger.cpp.

using logger::ClogSync = typedef sinks::synchronous_sink<sinks::text_ostream_backend>

Definition at line 340 of file Logger.cpp.

using logger::DurationTreeMap = typedef std::unordered_map<ThreadId, std::unique_ptr<DurationTree>>

Definition at line 648 of file Logger.cpp.

using logger::DurationTreeNode = typedef boost::variant<Duration, DurationTree&>

Definition at line 592 of file Logger.cpp.

using logger::DurationTreeNodes = typedef std::deque<DurationTreeNode>

Definition at line 593 of file Logger.cpp.

using logger::FatalFunc = typedef void (*)() noexcept

Definition at line 244 of file Logger.h.

using logger::FileSync = typedef sinks::synchronous_sink<sinks::text_file_backend>

Definition at line 341 of file Logger.cpp.

using logger::RequestId = typedef uint64_t

Definition at line 131 of file Logger.h.

typedef boost::log::sources::severity_logger_mt< Severity > logger::SeverityLogger

Definition at line 58 of file Logger.cpp.

using logger::ThreadId = typedef uint64_t

Definition at line 132 of file Logger.h.

Enumeration Type Documentation

enum logger::Channel

Enumerator
IR
PTX
ASM
_NCHANNELS

Definition at line 91 of file Logger.h.

{ IR = 0, PTX, ASM, _NCHANNELS };

enum logger::Severity

Enumerator
DEBUG4
DEBUG3
DEBUG2
DEBUG1
INFO
WARNING
ERROR
FATAL
_NSEVERITIES

Definition at line 103 of file Logger.h.

              {
  DEBUG4 = 0,
  DEBUG3,
  DEBUG2,
  DEBUG1,
  INFO,
  WARNING,
  ERROR,
  FATAL,
  _NSEVERITIES  // number of severity levels
};

Function Documentation

logger::BOOST_LOG_GLOBAL_LOGGER_CTOR_ARGS	(	gChannelLogger_IR	,
		ChannelLogger	,
		(keywords::channel=IR)
	)

template<typename X , typename Y >

BOOST_NOINLINE std::string* logger::check_failed	(	X const &	x,
		Y const &	y,
		char const *	xstr,
		char const *	ystr,
		char const *	op_str
	)

Definition at line 309 of file Logger.h.

                                                             {
  std::stringstream ss;
  ss << "Check failed: " << xstr << op_str << ystr << " (" << x << op_str << y << ") ";
  return new std::string(ss.str());  // Deleted by CHECK_OP macro.
}

void logger::debug_timer_new_thread

(

ThreadId const

parent_thread_id

)

Call this when a new thread is spawned that will have timers that need to be associated with timers on the parent thread. Required: g_thread_local_ids.thread_id_ is not yet in g_duration_tree_map.

Definition at line 855 of file Logger.cpp.

References CHECK, g_duration_tree_map, g_duration_tree_map_mutex, logger::anonymous_namespace{Logger.cpp}::g_thread_local_ids(), and logger::ThreadLocalIds::thread_id_.

                                                             {
  std::lock_guard<std::mutex> lock_guard(g_duration_tree_map_mutex);
  auto const parent_itr = g_duration_tree_map.find(parent_thread_id);
  CHECK(parent_itr != g_duration_tree_map.end()) << parent_thread_id;
  auto const current_depth = parent_itr->second->currentDepth();
  auto const emplaced = g_duration_tree_map.emplace(
      g_thread_local_ids.thread_id_,
      std::make_unique<DurationTree>(g_thread_local_ids.thread_id_, current_depth + 1));
  CHECK(emplaced.second) << "ThreadId " << g_thread_local_ids.thread_id_
                         << " already in map.";
  parent_itr->second->pushDurationTree(*emplaced.first->second);
}

Here is the call graph for this function:

bool logger::fast_logging_check ( Channel  )

inline

Definition at line 265 of file Logger.h.

References g_any_active_channels.

Referenced by anonymous_namespace{RelAlgOptimizer.cpp}::cleanup_dead_nodes(), fold_filters(), query_state::StdLog::log(), and query_state::StdLog::logCallStack().

                                        {
  extern bool g_any_active_channels;
  return g_any_active_channels;
}

Here is the caller graph for this function:

bool logger::fast_logging_check ( Severity  severity )

inline

Definition at line 270 of file Logger.h.

References g_min_active_severity.

                                                  {
  extern Severity g_min_active_severity;
  return g_min_active_severity <= severity;
}

boost::filesystem::path logger::get_log_dir_path

(

)

Definition at line 898 of file Logger.cpp.

References g_log_dir_path.

Referenced by Catalog_Namespace::Catalog::initializeSystemServers().

                          {
  return fs::canonical(g_log_dir_path);
}

Here is the caller graph for this function:

void logger::init

(

LogOptions const &

log_opts

)

Definition at line 360 of file Logger.cpp.

References _NSEVERITIES, logger::LogOptions::channels_, logger::LogOptions::full_log_dir(), g_any_active_channels, g_log_dir_path, g_min_active_severity, INFO, nvtx_helpers::init(), LOG, logger::LogOptions::max_files_, logger::LogOptions::severity_, and logger::LogOptions::severity_clog_.

Referenced by UdfCompiler::compileFromCommandLine(), UdfCompiler::generateAST(), QueryRunner::QueryRunner::init(), CommandLineOptions::init_logging(), main(), ColumnarResults::mergeResults(), ResultSetManager::reduce(), Executor::reduceMultiDeviceResultSets(), FixedLengthEncoder< T, V >::updateStatsEncoded(), and NoneEncoder< T >::updateStatsEncoded().

                                      {
  boost::shared_ptr<boost::log::core> core = boost::log::core::get();
  // boost::log::add_common_attributes(); // LineID TimeStamp ProcessID ThreadID
  core->add_global_attribute("TimeStamp", attr::local_clock());
  core->add_global_attribute("ProcessID", attr::current_process_id());
  if (0 < log_opts.max_files_) {
    fs::path const full_log_dir = log_opts.full_log_dir();
    auto collector = boost::make_shared<Collector>(full_log_dir, log_opts);
    bool const log_dir_was_created = fs::create_directory(full_log_dir);
    // Don't create separate log sinks for anything less than Severity::INFO.
    Severity const min_sink_level = std::max(Severity::INFO, log_opts.severity_);
    for (int i = min_sink_level; i < Severity::_NSEVERITIES; ++i) {
      Severity const level = static_cast<Severity>(i);
      core->add_sink(make_sink<FileSync>(collector, log_opts, full_log_dir, level));
    }
    g_min_active_severity = std::min(g_min_active_severity, log_opts.severity_);
    if (log_dir_was_created) {
      LOG(INFO) << "Log directory(" << full_log_dir.native() << ") created.";
    }
    for (auto const channel : log_opts.channels_) {
      core->add_sink(make_sink<FileSync>(collector, log_opts, full_log_dir, channel));
    }
    g_any_active_channels = !log_opts.channels_.empty();
  }
  core->add_sink(make_sink<ClogSync>(log_opts));
  g_min_active_severity = std::min(g_min_active_severity, log_opts.severity_clog_);
  nvtx_helpers::init();
  g_log_dir_path = log_opts.full_log_dir();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void logger::logAndEraseDurationTree

(

std::string *

json_str

)

Definition at line 805 of file Logger.cpp.

References CHECK, g_duration_tree_map, g_duration_tree_map_mutex, logger::anonymous_namespace{Logger.cpp}::g_thread_local_ids(), logger::JsonEncoder::str(), and logger::ThreadLocalIds::thread_id_.

Referenced by logger::DebugTimer::stop(), and logger::DebugTimer::stopAndGetJson().

                                                  {
  std::lock_guard<std::mutex> lock_guard(g_duration_tree_map_mutex);
  DurationTreeMap::const_iterator const itr =
      g_duration_tree_map.find(g_thread_local_ids.thread_id_);
  CHECK(itr != g_duration_tree_map.cend());
  auto const& root_duration = itr->second->rootDuration();
  if (auto log = Logger(root_duration->severity_)) {
    log.stream(root_duration->file_, root_duration->line_) << *itr;
  }
  if (json_str) {
    JsonEncoder json_encoder;
    *json_str = json_encoder.str(*itr);
  }
  EraseDurationTrees erase_duration_trees;
  erase_duration_trees(itr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename FILE_SINK , typename TAG >

boost::shared_ptr<FILE_SINK> logger::make_sink	(	boost::shared_ptr< Collector > &	collector,
		LogOptions const &	log_opts,
		fs::path const &	full_log_dir,
		TAG const	tag
	)

Definition at line 304 of file Logger.cpp.

References logger::LogOptions::auto_flush_, logger::LogOptions::file_name_pattern_, INFO, logger::LogOptions::rotate_daily_, logger::LogOptions::rotation_size_, logger::LogOptions::severity_, and logger::LogOptions::symlink_.

                                                      {
  auto sink = boost::make_shared<FILE_SINK>(
      keywords::file_name =
          full_log_dir / replace_braces(log_opts.file_name_pattern_, tag),
      keywords::auto_flush = log_opts.auto_flush_,
      keywords::rotation_size = log_opts.rotation_size_);
  if constexpr (std::is_same<TAG, Channel>::value) {
    sink->set_filter(channel == static_cast<Channel>(tag));
    set_formatter<Channel>(sink);
  } else {
    // INFO sink logs all other levels. Other sinks only log at their level or higher.
    Severity const min_filter_level = static_cast<Severity>(tag) == Severity::INFO
                                          ? log_opts.severity_
                                          : static_cast<Severity>(tag);
    sink->set_filter(min_filter_level <= severity);
    set_formatter<Severity>(sink);
  }
  typename FILE_SINK::locked_backend_ptr backend = sink->locked_backend();
  if (log_opts.rotate_daily_) {
    backend->set_time_based_rotation(sinks::file::rotation_at_time_point(0, 0, 0));
  }
  collector->track_symlink(full_log_dir / replace_braces(log_opts.symlink_, tag));
  backend->set_file_collector(collector);
  backend->set_open_handler(create_or_replace_symlink(
      boost::weak_ptr<FILE_SINK>(sink), replace_braces(log_opts.symlink_, tag)));
  backend->scan_for_files();
  return sink;
}

template<typename CONSOLE_SINK >

boost::shared_ptr<CONSOLE_SINK> logger::make_sink

(

LogOptions const &

log_opts

)

Definition at line 344 of file Logger.cpp.

References logger::LogOptions::severity_clog_.

                                                                    {
  auto sink = boost::make_shared<CONSOLE_SINK>();
  boost::shared_ptr<std::ostream> clog(&std::clog, boost::null_deleter());
  sink->locked_backend()->add_stream(clog);
  sink->set_filter(log_opts.severity_clog_ <= severity);
  set_formatter<Severity>(sink);
  return sink;
}

Duration* logger::newDuration

(

DebugTimerParams const

debug_timer_params

)

Definition at line 653 of file Logger.cpp.

References ERROR, logger::DebugTimerParams::file_, g_duration_tree_map, g_duration_tree_map_mutex, g_enable_debug_timer, logger::anonymous_namespace{Logger.cpp}::g_thread_local_ids(), logger::DebugTimerParams::line_, LOG, logger::DebugTimerParams::name_, and logger::ThreadLocalIds::thread_id_.

                                                                 {
  if (g_enable_debug_timer) {
    if (g_thread_local_ids.thread_id_) {
      std::lock_guard<std::mutex> lock_guard(g_duration_tree_map_mutex);
      auto& duration_tree_ptr = g_duration_tree_map[g_thread_local_ids.thread_id_];
      if (!duration_tree_ptr) {
        duration_tree_ptr =
            std::make_unique<DurationTree>(g_thread_local_ids.thread_id_, 0);
      }
      return duration_tree_ptr->newDuration(debug_timer_params);
    }
    LOG(ERROR) << "DEBUG_TIMER(" << debug_timer_params.name_
               << ") must not be called from the root thread(0) at "
               << debug_timer_params.file_ << ':' << debug_timer_params.line_
               << ". New threads require DEBUG_TIMER_NEW_THREAD() to be called first.";
  }
  return nullptr;  // Inactive - don't measure or report timing.
}

Here is the call graph for this function:

boost::log::formatting_ostream& logger::operator<<	(	boost::log::formatting_ostream &	strm,
		boost::log::to_log_manip< Channel, tag::channel > const &	manip
	)

Definition at line 272 of file Logger.cpp.

References ChannelSymbols.

                                                            {
  return strm << ChannelSymbols[manip.get()];
}

boost::log::formatting_ostream& logger::operator<<	(	boost::log::formatting_ostream &	strm,
		boost::log::to_log_manip< Severity, tag::severity > const &	manip
	)

Definition at line 278 of file Logger.cpp.

References SeveritySymbols.

                                                              {
  return strm << SeveritySymbols[manip.get()];
}

std::ostream& logger::operator<<	(	std::ostream &	out,
		Channels const &	channels
	)

Definition at line 440 of file Logger.cpp.

References ChannelNames.

                                                                  {
  int i = 0;
  for (auto const channel : channels) {
    out << (i++ ? " " : "") << ChannelNames.at(channel);
  }
  return out;
}

std::ostream& logger::operator<<	(	std::ostream &	out,
		Severity const &	sev
	)

Definition at line 463 of file Logger.cpp.

                                                             {
  return out << SeverityNames.at(sev);
}

std::ostream& logger::operator<<	(	std::ostream &	os,
		Duration const &	duration
	)

Definition at line 672 of file Logger.cpp.

References logger::Duration::depth_, logger::DebugTimerParams::file_, nvtx_helpers::anonymous_namespace{nvtx_helpers.cpp}::filename(), logger::DebugTimerParams::line_, logger::DebugTimerParams::name_, logger::Duration::relative_start_time(), and logger::Duration::value().

                                                                 {
  return os << std::setw(2 * duration.depth_) << ' ' << duration.value() << "ms start("
            << duration.relative_start_time() << "ms) " << duration->name_ << ' '
            << filename(duration->file_) << ':' << duration->line_;
}

Here is the call graph for this function:

std::ostream& logger::operator<<	(	std::ostream &	os,
		DurationTree const &	duration_tree
	)

Definition at line 678 of file Logger.cpp.

References logger::DurationTree::depth_, logger::DurationTree::durations(), and logger::DurationTree::thread_id_.

                                                                          {
  os << std::setw(2 * duration_tree.depth_) << ' ' << "New thread("
     << duration_tree.thread_id_ << ')';
  for (auto const& duration_tree_node : duration_tree.durations()) {
    os << '\n' << duration_tree_node;
  }
  return os << '\n'
            << std::setw(2 * duration_tree.depth_) << ' ' << "End thread("
            << duration_tree.thread_id_ << ')';
}

Here is the call graph for this function:

boost::log::record_ostream& logger::operator<<	(	boost::log::record_ostream &	os,
		DurationTreeMap::const_reference	kv_pair
	)

Definition at line 690 of file Logger.cpp.

                                                                               {
  auto itr = kv_pair.second->durations().cbegin();
  auto const end = kv_pair.second->durations().cend();
  auto const& root_duration = boost::get<Duration>(*itr);
  os << "DEBUG_TIMER thread_id(" << kv_pair.first << ")\n"
     << root_duration.value() << "ms total duration for " << root_duration->name_;
  for (++itr; itr != end; ++itr) {
    os << '\n' << *itr;
  }
  return os;
}

std::istream& logger::operator>>	(	std::istream &	in,
		Channels &	channels
	)

Definition at line 420 of file Logger.cpp.

References ChannelNames, parse_ast::line, and logger::anonymous_namespace{Logger.cpp}::unquote().

                                                           {
  std::string line;
  std::getline(in, line);
  unquote(line);
  std::regex const rex(R"(\w+)");
  using TokenItr = std::regex_token_iterator<std::string::iterator>;
  TokenItr const end;
  for (TokenItr tok(line.begin(), line.end(), rex); tok != end; ++tok) {
    auto itr = std::find(ChannelNames.cbegin(), ChannelNames.cend(), *tok);
    if (itr == ChannelNames.cend()) {
      in.setstate(std::ios_base::failbit);
      break;
    } else {
      channels.emplace(static_cast<Channel>(itr - ChannelNames.cbegin()));
    }
  }
  return in;
}

Here is the call graph for this function:

std::istream& logger::operator>>	(	std::istream &	in,
		Severity &	sev
	)

Definition at line 449 of file Logger.cpp.

References logger::anonymous_namespace{Logger.cpp}::unquote().

                                                      {
  std::string token;
  in >> token;
  unquote(token);
  auto itr = std::find(SeverityNames.cbegin(), SeverityNames.cend(), token);
  if (itr == SeverityNames.cend()) {
    in.setstate(std::ios_base::failbit);
  } else {
    sev = static_cast<Severity>(itr - SeverityNames.cbegin());
  }
  return in;
}

Here is the call graph for this function:

RequestId logger::request_id

(

)

Definition at line 868 of file Logger.cpp.

References logger::anonymous_namespace{Logger.cpp}::g_thread_local_ids(), and logger::ThreadLocalIds::request_id_.

Referenced by DBHandler::create_table(), populate_output_stats_cols(), DBHandler::processCalciteRequest(), set_request_id(), heavyai::RequestInfo::setRequestId(), and DBHandler::sql_execute_gdf().

                       {
  return g_thread_local_ids.request_id_;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename TAG , typename SINK >

void logger::set_formatter

(

SINK &

sink

)

Definition at line 285 of file Logger.cpp.

                               {
  if constexpr (std::is_same<TAG, Channel>::value) {
    sink->set_formatter(
        expr::stream << expr::format_date_time<boost::posix_time::ptime>(
                            "TimeStamp", "%Y-%m-%dT%H:%M:%S.%f")
                     << ' ' << channel << ' '
                     << boost::phoenix::bind(&get_native_process_id, process_id.or_none())
                     << ' ' << expr::smessage);
  } else {
    sink->set_formatter(
        expr::stream << expr::format_date_time<boost::posix_time::ptime>(
                            "TimeStamp", "%Y-%m-%dT%H:%M:%S.%f")
                     << ' ' << severity << ' '
                     << boost::phoenix::bind(&get_native_process_id, process_id.or_none())
                     << ' ' << expr::smessage);
  }
}

RequestId logger::set_new_request_id

(

)

Definition at line 883 of file Logger.cpp.

References logger::anonymous_namespace{Logger.cpp}::g_next_request_id, logger::anonymous_namespace{Logger.cpp}::g_next_thread_id, logger::anonymous_namespace{Logger.cpp}::g_thread_local_ids(), logger::ThreadLocalIds::request_id_, and logger::ThreadLocalIds::thread_id_.

Referenced by DBHandler::connect(), and DBHandler::internal_connect().

                               {
  if (g_thread_local_ids.thread_id_ == 0) {
    g_thread_local_ids.thread_id_ = g_next_thread_id++;
  }
  g_thread_local_ids.request_id_ = g_next_request_id++;
  return g_thread_local_ids.request_id_;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void logger::set_once_fatal_func

(

FatalFunc

fatal_func

)

Definition at line 390 of file Logger.cpp.

References g_fatal_func.

Referenced by QueryRunner::QueryRunner::QueryRunner().

                                               {
  if (g_fatal_func.exchange(fatal_func)) {
    throw std::runtime_error(
        "logger::set_once_fatal_func() should not be called more than once.");
  }
}

Here is the caller graph for this function:

void logger::set_request_id

(

RequestId const

request_id

)

Definition at line 891 of file Logger.cpp.

References logger::anonymous_namespace{Logger.cpp}::g_next_thread_id, logger::anonymous_namespace{Logger.cpp}::g_thread_local_ids(), request_id(), logger::ThreadLocalIds::request_id_, and logger::ThreadLocalIds::thread_id_.

                                                {
  if (g_thread_local_ids.thread_id_ == 0) {
    g_thread_local_ids.thread_id_ = g_next_thread_id++;
  }
  g_thread_local_ids.request_id_ = request_id;
}

Here is the call graph for this function:

void logger::shutdown

(

)

Definition at line 397 of file Logger.cpp.

References nvtx_helpers::shutdown().

Referenced by heartbeat(), EmbeddedDatabase::DBEngineImpl::reset(), TestProcessSignalHandler::shutdownSubsystemsAndExit(), startHeavyDBServer(), and logger::LogShutdown::~LogShutdown().

                {
  static std::once_flag logger_flag;
  std::call_once(logger_flag, []() {
    boost::log::core::get()->remove_all_sinks();
    nvtx_helpers::shutdown();
  });
}

Here is the call graph for this function:

Here is the caller graph for this function:

ThreadId logger::thread_id

(

)

Definition at line 871 of file Logger.cpp.

References logger::anonymous_namespace{Logger.cpp}::g_thread_local_ids(), and logger::ThreadLocalIds::thread_id_.

Referenced by import_export::import_thread_delimited(), import_export::import_thread_shapefile(), import_export::Importer::importDelimited(), import_export::Importer::importGDALGeo(), import_export::Importer::importGDALRaster(), foreign_storage::LazyParquetChunkLoader::loadRowGroups(), nvtx_helpers::name_current_thread(), StringDictionary::populate_string_array_ids(), and Parser::InsertIntoTableAsSelectStmt::populateData().

                     {
  return g_thread_local_ids.thread_id_;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ThreadLocalIds logger::thread_local_ids

(

)

Definition at line 874 of file Logger.cpp.

References logger::anonymous_namespace{Logger.cpp}::g_thread_local_ids().

Referenced by WindowFunctionContext::compute(), QueryRunner::QueryRunner::getCalcitePlan(), QueryRunner::QueryRunner::getRelAlgDag(), BaselineJoinHashTableBuilder::initHashTableOnCpu(), Executor::launchKernels(), query_state::StdLog::log(), query_state::StdLog::logCallStack(), ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::materializeApproxQuantileColumn(), ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::materializeCountDistinctColumn(), ResultSet::ResultSetComparator< BUFFER_ITERATOR_TYPE >::materializeModeColumn(), ResultSet::parallelRowCount(), ResultSet::parallelTop(), PerfectJoinHashTable::reify(), OverlapsJoinHashTable::reifyImpl(), RangeJoinHashTable::reifyWithLayout(), BaselineJoinHashTable::reifyWithLayout(), QueryRunner::QueryRunner::runSelectQuery(), QueryRunner::QueryRunner::runSQLWithAllowingInterrupt(), DBHandler::sql_execute_impl(), and DBHandler::validate_rel_alg().

                                  {
  return g_thread_local_ids;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

constexpr std::array<char const*, 3> logger::ChannelNames {"IR", "PTX", "ASM"}

Definition at line 93 of file Logger.h.

Referenced by operator<<(), and operator>>().

constexpr std::array<char, 3> logger::ChannelSymbols {'R', 'P', 'A'}

Definition at line 95 of file Logger.h.

Referenced by operator<<().

bool logger::g_any_active_channels {false}

Definition at line 355 of file Logger.cpp.

Referenced by fast_logging_check(), and init().

DurationTreeMap logger::g_duration_tree_map

Definition at line 651 of file Logger.cpp.

Referenced by debug_timer_new_thread(), logAndEraseDurationTree(), newDuration(), and logger::EraseDurationTrees::operator()().

std::mutex logger::g_duration_tree_map_mutex

Definition at line 650 of file Logger.cpp.

Referenced by debug_timer_new_thread(), logAndEraseDurationTree(), and newDuration().

std::atomic<FatalFunc> logger::g_fatal_func {nullptr}

Definition at line 337 of file Logger.cpp.

Referenced by set_once_fatal_func(), and logger::Logger::~Logger().

std::once_flag logger::g_fatal_func_flag

Definition at line 338 of file Logger.cpp.

Referenced by logger::Logger::~Logger().

fs::path logger::g_log_dir_path

static

Definition at line 358 of file Logger.cpp.

Referenced by get_log_dir_path(), and init().

Severity logger::g_min_active_severity {Severity::FATAL}

Definition at line 356 of file Logger.cpp.

Referenced by fast_logging_check(), and init().

constexpr std::array<char const*, 8> logger::SeverityNames

Initial value:

{"DEBUG4",
                                                   "DEBUG3",
                                                   "DEBUG2",
                                                   "DEBUG1",
                                                   "INFO",
                                                   "WARNING",
                                                   "ERROR",
                                                   "FATAL"}

Definition at line 115 of file Logger.h.

constexpr std::array<char, 8> logger::SeveritySymbols {'4', '3', '2', '1', 'I', 'W', 'E', 'F'}

Definition at line 124 of file Logger.h.

Referenced by operator<<().