QuickCppLib 0.10
Eliminate all the tedious hassle when making state-of-the-art C++ 14 - 23 libraries!
Loading...
Searching...
No Matches
quickcpplib::_xxx::ringbuffer_log::simple_ringbuffer_log_policy_detail Namespace Reference

Classes

struct  value_type

Typedefs

using level_ = level

Functions

std::string location (const value_type &v)
 Location generator for simple_ringbuffer_log_policy's value_type.
std::ostream & operator<< (std::ostream &s, const value_type &v)
 std::ostream writer for simple_ringbuffer_log_policy's value_type
std::ostream & csv (std::ostream &s, const value_type &v)
 CSV std::ostream writer for simple_ringbuffer_log_policy's value_type.

Typedef Documentation

◆ level_

Function Documentation

◆ location()

std::string quickcpplib::_xxx::ringbuffer_log::simple_ringbuffer_log_policy_detail::location ( const value_type & v)
inline

Location generator for simple_ringbuffer_log_policy's value_type.

240 {
241 std::string ret;
242 if(v.using_backtrace)
243 {
244 void *backtrace[16];
245 memset(backtrace, 0, sizeof(backtrace));
246 size_t len = 0;
247 {
249 for(auto *i : pb)
250 {
251 backtrace[len] = i;
252 len++;
253 if(len == sizeof(backtrace) / sizeof(backtrace[0]))
254 break;
255 }
256 }
257#ifndef _WIN32
258 bool done = false;
259 // Try llvm-symbolizer for nicer backtraces
260 int temp[2];
261 struct _h
262 {
263 int fd;
264 } childreadh, childwriteh, readh, writeh;
265 if(-1 != ::pipe(temp))
266 {
267 using namespace scope;
268 childreadh.fd = temp[0];
269 readh.fd = temp[1];
270 if(-1 != ::pipe(temp))
271 {
272 writeh.fd = temp[0];
273 childwriteh.fd = temp[1];
274 auto unmypipes = make_scope_exit([&]() noexcept {
275 (void) ::close(readh.fd);
276 (void) ::close(writeh.fd);
277 });
278 auto unhispipes = make_scope_exit([&]() noexcept {
279 (void) ::close(childreadh.fd);
280 (void) ::close(childwriteh.fd);
281 });
282 (void) ::fcntl(readh.fd, F_SETFD, FD_CLOEXEC);
283 (void) ::fcntl(writeh.fd, F_SETFD, FD_CLOEXEC);
284
285 posix_spawn_file_actions_t child_fd_actions;
286 if(!::posix_spawn_file_actions_init(&child_fd_actions))
287 {
288 auto unactions = make_scope_exit([&]() noexcept { ::posix_spawn_file_actions_destroy(&child_fd_actions); });
289 if(!::posix_spawn_file_actions_adddup2(&child_fd_actions, childreadh.fd, STDIN_FILENO))
290 {
291 if(!::posix_spawn_file_actions_addclose(&child_fd_actions, childreadh.fd))
292 {
293 if(!::posix_spawn_file_actions_adddup2(&child_fd_actions, childwriteh.fd, STDOUT_FILENO))
294 {
295 if(!::posix_spawn_file_actions_addclose(&child_fd_actions, childwriteh.fd))
296 {
297 pid_t pid;
298 std::vector<const char *> argptrs(2);
299 argptrs[0] = "llvm-symbolizer";
300 if(!::posix_spawnp(&pid, "llvm-symbolizer", &child_fd_actions, nullptr, (char **) argptrs.data(), environ))
301 {
302 (void) ::close(childreadh.fd);
303 (void) ::close(childwriteh.fd);
304 std::string addrs;
305 addrs.reserve(1024);
306 for(size_t n = 0; n < len; n++)
307 {
308 Dl_info info;
309 memset(&info, 0, sizeof(info));
310 ::dladdr(backtrace[n], &info);
311 if(info.dli_fname == nullptr)
312 {
313 break;
314 }
315 // std::cerr << bt[n] << " dli_fname = " << info.dli_fname << " dli_fbase = " << info.dli_fbase
316 // << std::endl;
317 addrs.append(info.dli_fname);
318 addrs.append(" 0x");
319 const bool has_slash = (strrchr(info.dli_fname, '/') != nullptr);
320 const bool is_dll = (strstr(info.dli_fname, ".so") != nullptr);
321 if(has_slash)
322 {
323 ssize_t diff;
324 if(is_dll)
325 {
326 diff = (char *) backtrace[n] - (char *) info.dli_fbase;
327 }
328 else
329 {
330 diff = (ssize_t) backtrace[n];
331 }
332 char buffer[32];
333 snprintf(buffer, 32, "%zx", diff);
334 buffer[31] = 0;
335 addrs.append(buffer);
336 }
337 else
338 {
339 char buffer[32];
340 snprintf(buffer, 32, "%zx", (uintptr_t) backtrace[n]);
341 buffer[31] = 0;
342 addrs.append(buffer);
343 }
344 addrs.push_back('\n');
345 }
346 // std::cerr << "\n\n---\n" << addrs << "---\n\n" << std::endl;
347 // Suppress SIGPIPE
348 sigset_t toblock, oldset;
349 sigemptyset(&toblock);
350 sigaddset(&toblock, SIGPIPE);
351 pthread_sigmask(SIG_BLOCK, &toblock, &oldset);
352 auto unsigmask = make_scope_exit([&toblock, &oldset]() noexcept {
353#ifdef __APPLE__
354 pthread_kill(pthread_self(), SIGPIPE);
355 int cleared = 0;
356 sigwait(&toblock, &cleared);
357#else
358 struct timespec ts = {0, 0};
359 sigtimedwait(&toblock, 0, &ts);
360#endif
361 pthread_sigmask(SIG_SETMASK, &oldset, nullptr);
362 });
363 (void) unsigmask;
364 ssize_t written = ::write(readh.fd, addrs.data(), addrs.size());
365 (void) ::close(readh.fd);
366 addrs.clear();
367 if(written != -1)
368 {
369 char buffer[1024];
370 for(;;)
371 {
372 auto bytes = ::read(writeh.fd, buffer, sizeof(buffer));
373 if(bytes < 1)
374 break;
375 addrs.append(buffer, bytes);
376 }
377 (void) ::close(writeh.fd);
378 unmypipes.release();
379 unhispipes.release();
380 }
381 // std::cerr << "\n\n---\n" << addrs << "---\n\n" << std::endl;
382 // reap child
383 siginfo_t info;
384 memset(&info, 0, sizeof(info));
385 int options = WEXITED | WSTOPPED;
386 if(-1 == ::waitid(P_PID, pid, &info, options))
387 abort();
388 if(!addrs.empty())
389 {
390 // We want the second line from every section separated by a double newline
391 size_t n = 0;
392 auto printitem = [&](size_t idx) {
393 if(n)
394 ret.append(", ");
395 auto idx2 = addrs.find(10, idx), idx3 = addrs.find(10, idx2 + 1);
396 ret.append(addrs.data() + idx2 + 1, idx3 - idx2 - 1);
397 n++;
398 };
399 size_t oldidx = 0;
400 for(size_t idx = addrs.find("\n\n"); idx != std::string::npos; oldidx = idx + 2, idx = addrs.find("\n\n", idx + 1))
401 {
402 printitem(oldidx);
403 }
404 done = true;
405 }
406 }
407 }
408 }
409 }
410 }
411 }
412 }
413 }
414 if(!done)
415#endif
416
417 {
418#if !QUICKCPPLIB_DISABLE_EXECINFO
419 char **symbols = backtrace_symbols(backtrace, len);
420 if(!symbols)
421 ret.append("BACKTRACE FAILED!");
422 else
423 {
424 for(size_t n = 0; n < len; n++)
425 {
426 if(symbols[n])
427 {
428 if(n)
429 ret.append(", ");
430 ret.append(symbols[n]);
431 }
432 }
433 free(symbols);
434 }
435#endif
436 }
437 }
438 else
439 {
440 char temp[256];
441 memcpy(temp, v.function, sizeof(v.function));
442 temp[sizeof(v.function)] = 0;
443 ret.append(temp);
444 }
445 return ret;
446 }
A space packed stack backtrace letting you store twice or more stack frames in the same space.
Definition packed_backtrace.hpp:550
EXECINFO_DECL _Check_return_ _In_ size_t len
Definition execinfo_win64.h:55
EXECINFO_DECL _Check_return_ size_t backtrace(_Out_writes_(len) void **bt, _In_ size_t len)
Fill the array of void * at bt with up to len entries, returning entries filled.
@ info
Definition ringbuffer_log.hpp:93
constexpr auto make_scope_exit(T &&v)
Definition scope.hpp:153

◆ operator<<()

std::ostream & quickcpplib::_xxx::ringbuffer_log::simple_ringbuffer_log_policy_detail::operator<< ( std::ostream & s,
const value_type & v )
inline

std::ostream writer for simple_ringbuffer_log_policy's value_type

449 {
450 s << "+" << std::setfill('0') << std::setw(16) << v.timestamp << " " << std::setfill(' ') << std::setw(1);
451 switch(v.level)
452 {
453 case 0:
454 s << "none: ";
455 break;
456 case 1:
457 s << "fatal: ";
458 break;
459 case 2:
460 s << "error: ";
461 break;
462 case 3:
463 s << "warn: ";
464 break;
465 case 4:
466 s << "info: ";
467 break;
468 case 5:
469 s << "debug: ";
470 break;
471 case 6:
472 s << "all: ";
473 break;
474 default:
475 s << "unknown: ";
476 break;
477 }
478 if(v.using_code64)
479 s << "{ " << v.code64 << " } ";
480 else
481 s << "{ " << v.code32[0] << ", " << v.code32[1] << " } ";
482 char temp[256];
483 memcpy(temp, v.message, sizeof(v.message));
484 temp[sizeof(v.message)] = 0;
485 s << temp << " @ ";
486 s << location(v);
487 return s << "\n";
488 }
std::string location(const value_type &v)
Location generator for simple_ringbuffer_log_policy's value_type.
Definition ringbuffer_log.hpp:239

◆ csv()

std::ostream & quickcpplib::_xxx::ringbuffer_log::simple_ringbuffer_log_policy_detail::csv ( std::ostream & s,
const value_type & v )
inline

CSV std::ostream writer for simple_ringbuffer_log_policy's value_type.

491 {
492 // timestamp,level,using_code64,using_backtrace,code0,code1,message,backtrace
493 s << v.timestamp << "," << (unsigned) v.level << "," << (unsigned) v.using_code64 << "," << (unsigned) v.using_backtrace << ",";
494 if(v.using_code64)
495 s << v.code64 << ",0,\"";
496 else
497 s << v.code32[0] << "," << v.code32[1] << ",\"";
498 char temp[256];
499 memcpy(temp, v.message, sizeof(v.message));
500 temp[sizeof(v.message)] = 0;
501 s << temp << "\",\"";
502 if(v.using_backtrace)
503 {
504#if !QUICKCPPLIB_DISABLE_EXECINFO
505 char **symbols = backtrace_symbols((void **) v.backtrace, sizeof(v.backtrace) / sizeof(v.backtrace[0]));
506 if(!symbols)
507 s << "BACKTRACE FAILED!";
508 else
509 {
510 for(size_t n = 0; n < sizeof(v.backtrace) / sizeof(v.backtrace[0]); n++)
511 {
512 if(symbols[n])
513 {
514 if(n)
515 s << ";";
516 s << symbols[n];
517 }
518 }
519 free(symbols);
520 }
521#endif
522 }
523 else
524 {
525 memcpy(temp, v.function, sizeof(v.function));
526 temp[sizeof(v.function)] = 0;
527 s << temp;
528 }
529 return s << "\"\n";
530 }