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_

using quickcpplib::_xxx::ringbuffer_log::simple_ringbuffer_log_policy_detail::level_ = typedef 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.

    {
      std::string ret;
      if(v.using_backtrace)
      {
        void *backtrace[16];
        memset(backtrace, 0, sizeof(backtrace));
        size_t len = 0;
        {
          packed_backtrace::packed_backtrace<> pb(v.backtrace);
          for(auto *i : pb)
          {
            backtrace[len] = i;
            len++;
            if(len == sizeof(backtrace) / sizeof(backtrace[0]))
              break;
          }
        }
#ifndef _WIN32
        bool done = false;
        // Try llvm-symbolizer for nicer backtraces
        int temp[2];
        struct _h
        {
          int fd;
        } childreadh, childwriteh, readh, writeh;
        if(-1 != ::pipe(temp))
        {
          using namespace scope;
          childreadh.fd = temp[0];
          readh.fd = temp[1];
          if(-1 != ::pipe(temp))
          {
            writeh.fd = temp[0];
            childwriteh.fd = temp[1];
            auto unmypipes = make_scope_exit([&]() noexcept {
              (void) ::close(readh.fd);
              (void) ::close(writeh.fd);
            });
            auto unhispipes = make_scope_exit([&]() noexcept {
              (void) ::close(childreadh.fd);
              (void) ::close(childwriteh.fd);
            });
            (void) ::fcntl(readh.fd, F_SETFD, FD_CLOEXEC);
            (void) ::fcntl(writeh.fd, F_SETFD, FD_CLOEXEC);
 
            posix_spawn_file_actions_t child_fd_actions;
            if(!::posix_spawn_file_actions_init(&child_fd_actions))
            {
              auto unactions = make_scope_exit([&]() noexcept { ::posix_spawn_file_actions_destroy(&child_fd_actions); });
              if(!::posix_spawn_file_actions_adddup2(&child_fd_actions, childreadh.fd, STDIN_FILENO))
              {
                if(!::posix_spawn_file_actions_addclose(&child_fd_actions, childreadh.fd))
                {
                  if(!::posix_spawn_file_actions_adddup2(&child_fd_actions, childwriteh.fd, STDOUT_FILENO))
                  {
                    if(!::posix_spawn_file_actions_addclose(&child_fd_actions, childwriteh.fd))
                    {
                      pid_t pid;
                      std::vector<const char *> argptrs(2);
                      argptrs[0] = "llvm-symbolizer";
                      if(!::posix_spawnp(&pid, "llvm-symbolizer", &child_fd_actions, nullptr, (char **) argptrs.data(), environ))
                      {
                        (void) ::close(childreadh.fd);
                        (void) ::close(childwriteh.fd);
                        std::string addrs;
                        addrs.reserve(1024);
                        for(size_t n = 0; n < len; n++)
                        {
                          Dl_info info;
                          memset(&info, 0, sizeof(info));
                          ::dladdr(backtrace[n], &info);
                          if(info.dli_fname == nullptr)
                          {
                            break;
                          }
                          // std::cerr << bt[n] << " dli_fname = " << info.dli_fname << " dli_fbase = " << info.dli_fbase
                          //          << std::endl;
                          addrs.append(info.dli_fname);
                          addrs.append(" 0x");
                          const bool has_slash = (strrchr(info.dli_fname, '/') != nullptr);
                          const bool is_dll = (strstr(info.dli_fname, ".so") != nullptr);
                          if(has_slash)
                          {
                            ssize_t diff;
                            if(is_dll)
                            {
                              diff = (char *) backtrace[n] - (char *) info.dli_fbase;
                            }
                            else
                            {
                              diff = (ssize_t) backtrace[n];
                            }
                            char buffer[32];
                            snprintf(buffer, 32, "%zx", diff);
                            buffer[31] = 0;
                            addrs.append(buffer);
                          }
                          else
                          {
                            char buffer[32];
                            snprintf(buffer, 32, "%zx", (uintptr_t) backtrace[n]);
                            buffer[31] = 0;
                            addrs.append(buffer);
                          }
                          addrs.push_back('\n');
                        }
                        // std::cerr << "\n\n---\n" << addrs << "---\n\n" << std::endl;
                        // Suppress SIGPIPE
                        sigset_t toblock, oldset;
                        sigemptyset(&toblock);
                        sigaddset(&toblock, SIGPIPE);
                        pthread_sigmask(SIG_BLOCK, &toblock, &oldset);
                        auto unsigmask = make_scope_exit([&toblock, &oldset]() noexcept {
#ifdef __APPLE__
                          pthread_kill(pthread_self(), SIGPIPE);
                          int cleared = 0;
                          sigwait(&toblock, &cleared);
#else
                          struct timespec ts = {0, 0};
                          sigtimedwait(&toblock, 0, &ts);
#endif
                          pthread_sigmask(SIG_SETMASK, &oldset, nullptr);
                        });
                        (void) unsigmask;
                        ssize_t written = ::write(readh.fd, addrs.data(), addrs.size());
                        (void) ::close(readh.fd);
                        addrs.clear();
                        if(written != -1)
                        {
                          char buffer[1024];
                          for(;;)
                          {
                            auto bytes = ::read(writeh.fd, buffer, sizeof(buffer));
                            if(bytes < 1)
                              break;
                            addrs.append(buffer, bytes);
                          }
                          (void) ::close(writeh.fd);
                          unmypipes.release();
                          unhispipes.release();
                        }
                        // std::cerr << "\n\n---\n" << addrs << "---\n\n" << std::endl;
                        // reap child
                        siginfo_t info;
                        memset(&info, 0, sizeof(info));
                        int options = WEXITED | WSTOPPED;
                        if(-1 == ::waitid(P_PID, pid, &info, options))
                          abort();
                        if(!addrs.empty())
                        {
                          // We want the second line from every section separated by a double newline
                          size_t n = 0;
                          auto printitem = [&](size_t idx) {
                            if(n)
                              ret.append(", ");
                            auto idx2 = addrs.find(10, idx), idx3 = addrs.find(10, idx2 + 1);
                            ret.append(addrs.data() + idx2 + 1, idx3 - idx2 - 1);
                            n++;
                          };
                          size_t oldidx = 0;
                          for(size_t idx = addrs.find("\n\n"); idx != std::string::npos; oldidx = idx + 2, idx = addrs.find("\n\n", idx + 1))
                          {
                            printitem(oldidx);
                          }
                          done = true;
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
        if(!done)
#endif
 
        {
#if !QUICKCPPLIB_DISABLE_EXECINFO
          char **symbols = backtrace_symbols(backtrace, len);
          if(!symbols)
            ret.append("BACKTRACE FAILED!");
          else
          {
            for(size_t n = 0; n < len; n++)
            {
              if(symbols[n])
              {
                if(n)
                  ret.append(", ");
                ret.append(symbols[n]);
              }
            }
            free(symbols);
          }
#endif
        }
      }
      else
      {
        char temp[256];
        memcpy(temp, v.function, sizeof(v.function));
        temp[sizeof(v.function)] = 0;
        ret.append(temp);
      }
      return ret;
    }

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

    {
      s << "+" << std::setfill('0') << std::setw(16) << v.timestamp << " " << std::setfill(' ') << std::setw(1);
      switch(v.level)
      {
      case 0:
        s << "none:  ";
        break;
      case 1:
        s << "fatal: ";
        break;
      case 2:
        s << "error: ";
        break;
      case 3:
        s << "warn:  ";
        break;
      case 4:
        s << "info:  ";
        break;
      case 5:
        s << "debug: ";
        break;
      case 6:
        s << "all:   ";
        break;
      default:
        s << "unknown: ";
        break;
      }
      if(v.using_code64)
        s << "{ " << v.code64 << " } ";
      else
        s << "{ " << v.code32[0] << ", " << v.code32[1] << " } ";
      char temp[256];
      memcpy(temp, v.message, sizeof(v.message));
      temp[sizeof(v.message)] = 0;
      s << temp << " @ ";
      s << location(v);
      return s << "\n";
    }

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.

    {
      // timestamp,level,using_code64,using_backtrace,code0,code1,message,backtrace
      s << v.timestamp << "," << (unsigned) v.level << "," << (unsigned) v.using_code64 << "," << (unsigned) v.using_backtrace << ",";
      if(v.using_code64)
        s << v.code64 << ",0,\"";
      else
        s << v.code32[0] << "," << v.code32[1] << ",\"";
      char temp[256];
      memcpy(temp, v.message, sizeof(v.message));
      temp[sizeof(v.message)] = 0;
      s << temp << "\",\"";
      if(v.using_backtrace)
      {
#if !QUICKCPPLIB_DISABLE_EXECINFO
        char **symbols = backtrace_symbols((void **) v.backtrace, sizeof(v.backtrace) / sizeof(v.backtrace[0]));
        if(!symbols)
          s << "BACKTRACE FAILED!";
        else
        {
          for(size_t n = 0; n < sizeof(v.backtrace) / sizeof(v.backtrace[0]); n++)
          {
            if(symbols[n])
            {
              if(n)
                s << ";";
              s << symbols[n];
            }
          }
          free(symbols);
        }
#endif
      }
      else
      {
        memcpy(temp, v.function, sizeof(v.function));
        temp[sizeof(v.function)] = 0;
        s << temp;
      }
      return s << "\"\n";
    }