27009203599

Committed 05 Jun 2026 10:17AM UTC coverage: 18.437%. First build

Build # 27009203599

Build Type

Pull #352

github

Committed by

web-flow

Commit Message

Merge 93add864a into a4a7a5cb6

Pull Request Pull Request #352: fix: update logger types and improve error logging messages

Coverage Stats

7268 of 53566 branches covered (13.57%)

Branch coverage included in aggregate %.

380 of 702 new or added lines in 31 files covered. (54.13%)

4776 of 11760 relevant lines covered (40.61%)

1107.23 hits per line

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

25.78

/src/dftracer/core/serialization/json_line.cpp

#include <dftracer/core/common/constants.h>
#include <dftracer/core/common/datastructure.h>
#include <dftracer/core/common/logging.h>
#include <dftracer/core/common/singleton.h>
#include <dftracer/core/serialization/json_line.h>
#include <dftracer/core/utils/utils.h>

#include <cstring>
#include <memory>
#include <mutex>

static constexpr size_t DFTRACER_SERIALIZATION_EVENT_MAX = 16 * 1024;
namespace dftracer {
template <>
std::shared_ptr<JsonLines> Singleton<JsonLines>::instance = nullptr;
template <>
bool Singleton<JsonLines>::stop_creating_instances = false;
JsonLines::JsonLines() : include_metadata(false) {
  auto conf = Singleton<ConfigurationManager>::get_instance();
  include_metadata = conf->metadata;
}

size_t JsonLines::initialize(char* buffer, HashType hostname_hash) {
  this->hostname_hash = hostname_hash;
  buffer[0] = '[';
  buffer[1] = '\n';
  return 2;
}

bool JsonLines::convert_metadata(Metadata* metadata,
                                 std::stringstream& meta_stream) {
  if (metadata == nullptr) return false;
  auto meta_size = metadata->size();
  long unsigned int i = 0;
  bool has_meta = false;
  for (const auto& item : *metadata) {
    has_meta = true;
    DFTRACER_FOR_EACH_NUMERIC_TYPE(
        DFTRACER_ANY_CAST_MACRO, std::get<1>(item.second), {
          meta_stream << "\"" << item.first << "\":" << res.value();
          if (i < meta_size - 1) meta_stream << ",";
          i++;
          continue;
        });
    DFTRACER_FOR_EACH_STRING_TYPE(
        DFTRACER_ANY_CAST_MACRO, std::get<1>(item.second), {
          meta_stream << "\"" << item.first << "\":\"" << res.value() << "\"";
          if (i < meta_size - 1) meta_stream << ",";
          i++;
          continue;
        });
    i++;
  }
  if (meta_stream.str().size() > 0 && meta_stream.str().back() == ',') {
    std::string temp = meta_stream.str();
    temp.pop_back();
    meta_stream.str("");
    meta_stream.clear();
    meta_stream << temp;
  }
  delete metadata;
  return has_meta;
}

size_t JsonLines::data(char* buffer, int index, ConstEventNameType event_name,
                       ConstEventNameType category, TimeResolution start_time,
                       TimeResolution duration, dftracer::Metadata* metadata,
                       ProcessID process_id, ThreadID thread_id) {
  size_t written_size = 0;
  int n = 0;
  if (include_metadata && metadata != nullptr) {
    std::stringstream all_stream;
    std::stringstream meta_stream;
    bool has_meta = convert_metadata(metadata, meta_stream);

    if (has_meta) {
      all_stream << "," << meta_stream.str();
    }
    n = snprintf(
        buffer, DFTRACER_SERIALIZATION_EVENT_MAX,
        R"({"id":%d,"name":"%s","cat":"%s","pid":%d,"tid":%lu,"ts":%llu,"dur":%llu,"ph":"X","args":{"hhash":"%s"%s}})",
        index, event_name, category, process_id, thread_id, start_time,
        duration, this->hostname_hash, all_stream.str().c_str());
  } else {
    n = snprintf(
        buffer, DFTRACER_SERIALIZATION_EVENT_MAX,
        R"({"id":%d,"name":"%s","cat":"%s","pid":%d,"tid":%lu,"ts":%llu,"dur":%llu,"ph":"X"})",
        index, event_name, category, process_id, thread_id, start_time,
        duration);
  }
  if (n < 0) {
    return 0;
  }
  written_size = (static_cast<size_t>(n) >= DFTRACER_SERIALIZATION_EVENT_MAX)
                     ? DFTRACER_SERIALIZATION_EVENT_MAX - 1
                     : static_cast<size_t>(n);
  if (static_cast<size_t>(n) >= DFTRACER_SERIALIZATION_EVENT_MAX) {
    DFTRACER_LOG_WARN("JsonLines.data truncated event %d to %zu bytes", index,
                      DFTRACER_SERIALIZATION_EVENT_MAX - 1);
  }
  if (written_size + 1 < DFTRACER_SERIALIZATION_EVENT_MAX) {
    buffer[written_size++] = '\n';
    buffer[written_size] = '\0';
  } else {
    buffer[DFTRACER_SERIALIZATION_EVENT_MAX - 1] = '\0';
  }
  DFTRACER_LOG_DEBUG("JsonLines.serialize %s", buffer);
  return written_size;
}

size_t JsonLines::counter(char* buffer, int index,
                          ConstEventNameType event_name,
                          ConstEventNameType category,
                          TimeResolution start_time, ProcessID process_id,
                          ThreadID thread_id, dftracer::Metadata* metadata) {
  size_t written_size = 0;
  int n = 0;
  if (metadata != nullptr && !metadata->empty()) {
    std::stringstream all_stream;
    std::stringstream meta_stream;
    bool has_meta = convert_metadata(metadata, meta_stream);
    if (has_meta) {
      all_stream << "," << meta_stream.str();
    }
    n = snprintf(
        buffer, DFTRACER_SERIALIZATION_EVENT_MAX,
        R"({"name":"%s","cat":"%s","ts":%llu,"ph":"C","pid":%d,"tid":%lu,"args":{"hhash":"%s"%s}})",
        event_name, category, start_time, process_id, thread_id,
        this->hostname_hash, all_stream.str().c_str());
  } else {
    n = snprintf(
        buffer, DFTRACER_SERIALIZATION_EVENT_MAX,
        R"({"name":"%s","cat":"%s","ts":%llu,"ph":"C","pid":%d,"tid":%lu})",
        event_name, category, start_time, process_id, thread_id);
  }
  if (n < 0) {
    return 0;
  }
  written_size = (static_cast<size_t>(n) >= DFTRACER_SERIALIZATION_EVENT_MAX)
                     ? DFTRACER_SERIALIZATION_EVENT_MAX - 1
                     : static_cast<size_t>(n);
  if (static_cast<size_t>(n) >= DFTRACER_SERIALIZATION_EVENT_MAX) {
    DFTRACER_LOG_WARN("JsonLines.counter truncated event %d to %zu bytes",
                      index, DFTRACER_SERIALIZATION_EVENT_MAX - 1);
  }
  if (written_size + 1 < DFTRACER_SERIALIZATION_EVENT_MAX) {
    buffer[written_size++] = '\n';
    buffer[written_size] = '\0';
  } else {
    buffer[DFTRACER_SERIALIZATION_EVENT_MAX - 1] = '\0';
  }
  DFTRACER_LOG_DEBUG("JsonLines.serialize %s", buffer);
  return written_size;
}

size_t JsonLines::metadata(char* buffer, ConstEventNameType name,
                           ConstEventNameType value, ConstEventNameType ph,
                           ProcessID process_id, ThreadID thread_id,
                           bool is_string) {
  size_t written_size = 0;
  int n = 0;
  if (is_string) {
    n = snprintf(
        buffer, DFTRACER_SERIALIZATION_EVENT_MAX,
        R"({"name":"%s","cat":"dftracer","pid":%d,"tid":%lu,"ph":"M","args":{"hhash":"%s","name":"%s","value":"%s"}})",
        ph, process_id, thread_id, this->hostname_hash, name, value);
  } else {
    n = snprintf(
        buffer, DFTRACER_SERIALIZATION_EVENT_MAX,
        R"({"name":"%s","cat":"dftracer","pid":%d,"tid":%lu,"ph":"M","args":{"hhash":"%s","name":"%s","value":%s}})",
        ph, process_id, thread_id, this->hostname_hash, name, value);
  }
  if (n < 0) {
    return 0;
  }
  written_size = (static_cast<size_t>(n) >= DFTRACER_SERIALIZATION_EVENT_MAX)
                     ? DFTRACER_SERIALIZATION_EVENT_MAX - 1
                     : static_cast<size_t>(n);
  if (static_cast<size_t>(n) >= DFTRACER_SERIALIZATION_EVENT_MAX) {
    DFTRACER_LOG_WARN(
        "JsonLines.metadata truncated metadata event to %zu bytes",
        DFTRACER_SERIALIZATION_EVENT_MAX - 1);
  }
  if (written_size + 1 < DFTRACER_SERIALIZATION_EVENT_MAX) {
    buffer[written_size++] = '\n';
    buffer[written_size] = '\0';
  } else {
    buffer[DFTRACER_SERIALIZATION_EVENT_MAX - 1] = '\0';
  }
  DFTRACER_LOG_DEBUG("ChromeWriter.convert_json_metadata %s", buffer);
  return written_size;
}

#define BASE_ANY_ID_MACRO(TYPE, VALUE, BLOCK) \
  if (_id == typeid(TYPE)) {                  \
    BLOCK;                                    \
  }

size_t JsonLines::aggregated(char* buffer, int index, ProcessID process_id,
                             dftracer::AggregatedDataType& data) {
  size_t total_written = 0;

  DFTRACER_LOG_INFO("Writing %d intervals", data.size());
  for (const auto& interval_entry : data) {
    const TimeResolution& interval = interval_entry.first;
    const auto& event_map = interval_entry.second;
    DFTRACER_LOG_INFO("Writing %d events for %llu", event_map.size(), interval);
    for (const auto& event_entry : event_map) {
      AggregatedValues* event_values = event_entry.second;
      auto key = event_entry.first;
      auto metadata = key.additional_keys;
      for (const auto& value_entry : event_values->values) {
        const std::string& base_key = value_entry.first;
        BaseAggregatedValue* base_value = value_entry.second;
        if (!base_value) continue;
        // metadata->erase(base_key);
        auto id = base_value->_id;
        DFTRACER_FOR_EACH_NUMERIC_TYPE(DFTRACER_ANY_NUM_AGGREGATE_MACRO,
                                       base_value, { continue; });
        DFTRACER_FOR_EACH_STRING_TYPE(DFTRACER_ANY_GENERAL_AGGREGATE_MACRO,
                                      base_value, { continue; });
      }
      total_written += counter(buffer + total_written, index,
                               key.event_name.c_str(), key.category.c_str(),
                               interval, process_id, key.thread_id, metadata);
    }
  }
  Aggregator::release_aggregated_data(data);
  return total_written;
}

}  // namespace dftracer

1	#include <dftracer/core/common/constants.h>
2	#include <dftracer/core/common/datastructure.h>
3	#include <dftracer/core/common/logging.h>
4	#include <dftracer/core/common/singleton.h>
5	#include <dftracer/core/serialization/json_line.h>
6	#include <dftracer/core/utils/utils.h>
7
8	#include <cstring>
9	#include <memory>
10	#include <mutex>
11
12	static constexpr size_t DFTRACER_SERIALIZATION_EVENT_MAX = 16 * 1024;
13	namespace dftracer {
14	template <>
15	std::shared_ptr<JsonLines> Singleton<JsonLines>::instance = nullptr;
16	template <>
17	bool Singleton<JsonLines>::stop_creating_instances = false;
18	JsonLines::JsonLines() : include_metadata(false) {	65✔
19	auto conf = Singleton<ConfigurationManager>::get_instance();	65✔
20	include_metadata = conf->metadata;	65✔
21	}	65✔
22
23	size_t JsonLines::initialize(char* buffer, HashType hostname_hash) {	68✔
24	this->hostname_hash = hostname_hash;	68✔
25	buffer[0] = '[';	68✔
26	buffer[1] = '\n';	68✔
27	return 2;	68✔
28	}
29
30	bool JsonLines::convert_metadata(Metadata* metadata,	1,509✔
31	std::stringstream& meta_stream) {
32	if (metadata == nullptr) return false;	1,509!
33	auto meta_size = metadata->size();	1,509✔
34	long unsigned int i = 0;	1,509✔
35	bool has_meta = false;	1,509✔
36	for (const auto& item : *metadata) {	5,773✔
37	has_meta = true;	4,264✔
38	DFTRACER_FOR_EACH_NUMERIC_TYPE(	4,264!
39	DFTRACER_ANY_CAST_MACRO, std::get<1>(item.second), {
40	meta_stream << "\"" << item.first << "\":" << res.value();
41	if (i < meta_size - 1) meta_stream << ",";
42	i++;
43	continue;
44	});
45	DFTRACER_FOR_EACH_STRING_TYPE(	937!
46	DFTRACER_ANY_CAST_MACRO, std::get<1>(item.second), {
47	meta_stream << "\"" << item.first << "\":\"" << res.value() << "\"";
48	if (i < meta_size - 1) meta_stream << ",";
49	i++;
50	continue;
51	});
52	i++;	×
53	}
54	if (meta_stream.str().size() > 0 && meta_stream.str().back() == ',') {	1,509!
55	std::string temp = meta_stream.str();	×
56	temp.pop_back();	×
57	meta_stream.str("");	×
58	meta_stream.clear();	×
59	meta_stream << temp;	×
60	}	×
61	delete metadata;	1,509!
62	return has_meta;	1,509✔
63	}
64
65	size_t JsonLines::data(char* buffer, int index, ConstEventNameType event_name,	1,410✔
66	ConstEventNameType category, TimeResolution start_time,
67	TimeResolution duration, dftracer::Metadata* metadata,
68	ProcessID process_id, ThreadID thread_id) {
69	size_t written_size = 0;	1,410✔
70	int n = 0;	1,410✔
71	if (include_metadata && metadata != nullptr) {	1,410✔
72	std::stringstream all_stream;	1,395✔
73	std::stringstream meta_stream;	1,395✔
74	bool has_meta = convert_metadata(metadata, meta_stream);	1,395✔
75
76	if (has_meta) {	1,395✔
77	all_stream << "," << meta_stream.str();	1,147✔
78	}
79	n = snprintf(	1,395✔
80	buffer, DFTRACER_SERIALIZATION_EVENT_MAX,
81	R"({"id":%d,"name":"%s","cat":"%s","pid":%d,"tid":%lu,"ts":%llu,"dur":%llu,"ph":"X","args":{"hhash":"%s"%s}})",
82	index, event_name, category, process_id, thread_id, start_time,
83	duration, this->hostname_hash, all_stream.str().c_str());	2,790✔
84	} else {	1,395✔
85	n = snprintf(	15✔
86	buffer, DFTRACER_SERIALIZATION_EVENT_MAX,
87	R"({"id":%d,"name":"%s","cat":"%s","pid":%d,"tid":%lu,"ts":%llu,"dur":%llu,"ph":"X"})",
88	index, event_name, category, process_id, thread_id, start_time,
89	duration);
90	}
91	if (n < 0) {	1,410!
NEW 92	return 0;	×
93	}
94	written_size = (static_cast<size_t>(n) >= DFTRACER_SERIALIZATION_EVENT_MAX)	1,410✔
95	? DFTRACER_SERIALIZATION_EVENT_MAX - 1
96	: static_cast<size_t>(n);
97	if (static_cast<size_t>(n) >= DFTRACER_SERIALIZATION_EVENT_MAX) {	1,410!
NEW 98	DFTRACER_LOG_WARN("JsonLines.data truncated event %d to %zu bytes", index,	×
99	DFTRACER_SERIALIZATION_EVENT_MAX - 1);
100	}
101	if (written_size + 1 < DFTRACER_SERIALIZATION_EVENT_MAX) {	1,410!
102	buffer[written_size++] = '\n';	1,410✔
103	buffer[written_size] = '\0';	1,410✔
104	} else {
NEW 105	buffer[DFTRACER_SERIALIZATION_EVENT_MAX - 1] = '\0';	×
106	}
107	DFTRACER_LOG_DEBUG("JsonLines.serialize %s", buffer);	1,045✔
108	return written_size;	1,410✔
109	}
110
111	size_t JsonLines::counter(char* buffer, int index,	114✔
112	ConstEventNameType event_name,
113	ConstEventNameType category,
114	TimeResolution start_time, ProcessID process_id,
115	ThreadID thread_id, dftracer::Metadata* metadata) {
116	size_t written_size = 0;	114✔
117	int n = 0;	114✔
118	if (metadata != nullptr && !metadata->empty()) {	114!
119	std::stringstream all_stream;	114✔
120	std::stringstream meta_stream;	114✔
121	bool has_meta = convert_metadata(metadata, meta_stream);	114✔
122	if (has_meta) {	114!
123	all_stream << "," << meta_stream.str();	114✔
124	}
125	n = snprintf(	114✔
126	buffer, DFTRACER_SERIALIZATION_EVENT_MAX,
127	R"({"name":"%s","cat":"%s","ts":%llu,"ph":"C","pid":%d,"tid":%lu,"args":{"hhash":"%s"%s}})",
128	event_name, category, start_time, process_id, thread_id,
129	this->hostname_hash, all_stream.str().c_str());	228✔
130	} else {	114✔
NEW 131	n = snprintf(	×
132	buffer, DFTRACER_SERIALIZATION_EVENT_MAX,
133	R"({"name":"%s","cat":"%s","ts":%llu,"ph":"C","pid":%d,"tid":%lu})",
134	event_name, category, start_time, process_id, thread_id);
135	}
136	if (n < 0) {	114!
NEW 137	return 0;	×
138	}
139	written_size = (static_cast<size_t>(n) >= DFTRACER_SERIALIZATION_EVENT_MAX)	114✔
140	? DFTRACER_SERIALIZATION_EVENT_MAX - 1
141	: static_cast<size_t>(n);
142	if (static_cast<size_t>(n) >= DFTRACER_SERIALIZATION_EVENT_MAX) {	114!
NEW 143	DFTRACER_LOG_WARN("JsonLines.counter truncated event %d to %zu bytes",	×
144	index, DFTRACER_SERIALIZATION_EVENT_MAX - 1);
145	}
146	if (written_size + 1 < DFTRACER_SERIALIZATION_EVENT_MAX) {	114!
147	buffer[written_size++] = '\n';	114✔
148	buffer[written_size] = '\0';	114✔
149	} else {
NEW 150	buffer[DFTRACER_SERIALIZATION_EVENT_MAX - 1] = '\0';	×
151	}
152	DFTRACER_LOG_DEBUG("JsonLines.serialize %s", buffer);	2✔
153	return written_size;	114✔
154	}
155
156	size_t JsonLines::metadata(char* buffer, ConstEventNameType name,	503✔
157	ConstEventNameType value, ConstEventNameType ph,
158	ProcessID process_id, ThreadID thread_id,
159	bool is_string) {
160	size_t written_size = 0;	503✔
161	int n = 0;	503✔
162	if (is_string) {	503!
163	n = snprintf(	503✔
164	buffer, DFTRACER_SERIALIZATION_EVENT_MAX,
165	R"({"name":"%s","cat":"dftracer","pid":%d,"tid":%lu,"ph":"M","args":{"hhash":"%s","name":"%s","value":"%s"}})",
166	ph, process_id, thread_id, this->hostname_hash, name, value);
167	} else {
NEW 168	n = snprintf(	×
169	buffer, DFTRACER_SERIALIZATION_EVENT_MAX,
170	R"({"name":"%s","cat":"dftracer","pid":%d,"tid":%lu,"ph":"M","args":{"hhash":"%s","name":"%s","value":%s}})",
171	ph, process_id, thread_id, this->hostname_hash, name, value);
172	}
173	if (n < 0) {	503!
NEW 174	return 0;	×
175	}
176	written_size = (static_cast<size_t>(n) >= DFTRACER_SERIALIZATION_EVENT_MAX)	503✔
177	? DFTRACER_SERIALIZATION_EVENT_MAX - 1
178	: static_cast<size_t>(n);
179	if (static_cast<size_t>(n) >= DFTRACER_SERIALIZATION_EVENT_MAX) {	503!
NEW 180	DFTRACER_LOG_WARN(	×
181	"JsonLines.metadata truncated metadata event to %zu bytes",
182	DFTRACER_SERIALIZATION_EVENT_MAX - 1);
183	}
184	if (written_size + 1 < DFTRACER_SERIALIZATION_EVENT_MAX) {	503!
185	buffer[written_size++] = '\n';	503✔
186	buffer[written_size] = '\0';	503✔
187	} else {
NEW 188	buffer[DFTRACER_SERIALIZATION_EVENT_MAX - 1] = '\0';	×
189	}
190	DFTRACER_LOG_DEBUG("ChromeWriter.convert_json_metadata %s", buffer);	459✔
191	return written_size;	503✔
192	}
193
194	#define BASE_ANY_ID_MACRO(TYPE, VALUE, BLOCK) \
195	if (_id == typeid(TYPE)) { \
196	BLOCK; \
197	}
198
199	size_t JsonLines::aggregated(char* buffer, int index, ProcessID process_id,	2✔
200	dftracer::AggregatedDataType& data) {
201	size_t total_written = 0;	2✔
202
203	DFTRACER_LOG_INFO("Writing %d intervals", data.size());	2✔
204	for (const auto& interval_entry : data) {	4!
205	const TimeResolution& interval = interval_entry.first;	2✔
206	const auto& event_map = interval_entry.second;	2✔
207	DFTRACER_LOG_INFO("Writing %d events for %llu", event_map.size(), interval);	2✔
208	for (const auto& event_entry : event_map) {	4!
209	AggregatedValues* event_values = event_entry.second;	2✔
210	auto key = event_entry.first;	2!
211	auto metadata = key.additional_keys;	2✔
212	for (const auto& value_entry : event_values->values) {	2!
NEW 213	const std::string& base_key = value_entry.first;	×
NEW 214	BaseAggregatedValue* base_value = value_entry.second;	×
215	if (!base_value) continue;	×
216	// metadata->erase(base_key);
217	auto id = base_value->_id;	×
218	DFTRACER_FOR_EACH_NUMERIC_TYPE(DFTRACER_ANY_NUM_AGGREGATE_MACRO,	×
219	base_value, { continue; });
220	DFTRACER_FOR_EACH_STRING_TYPE(DFTRACER_ANY_GENERAL_AGGREGATE_MACRO,	×
221	base_value, { continue; });
222	}
223	total_written += counter(buffer + total_written, index,	2!
224	key.event_name.c_str(), key.category.c_str(),
225	interval, process_id, key.thread_id, metadata);
226	}	2✔
227	}
228	Aggregator::release_aggregated_data(data);	2✔
229	return total_written;	2✔
230	}
231
232	} // namespace dftracer

llnl / dftracer / 27009203599

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