Added thread pid to console log for multithread environment

include/fc/log/console_appender.hpp

@@ -37,7 +37,7 @@ namespace fc
             struct config 
             {
                config()
-               :format( "${timestamp} ${thread_name} ${context} ${file}:${line} ${method} ${level}]  ${message}" ),
+               :format( "${timestamp} ${thread_name} ${thread_pid} ${context} ${file}:${line} ${method} ${level}]  ${message}" ),
                 stream(console_appender::stream::std_error),flush(true){}
 
                fc::string                         format;

include/fc/log/log_message.hpp

@@ -69,6 +69,7 @@ namespace fc
         uint64_t      get_line_number()const;
         string        get_method()const;
         string        get_thread_name()const;
+        pid_t         get_thread_pid()const;
         string        get_task_name()const;
         string        get_host_name()const;
         time_point    get_timestamp()const;

include/fc/log/logger_config.hpp

@@ -44,6 +44,9 @@ namespace fc {
 
    void set_thread_name( const string& name );
    const string& get_thread_name();
+
+   void set_thread_pid( const pid_t& pid );
+   const pid_t& get_thread_pid();
 }
 
 #include <fc/reflect/reflect.hpp>

src/log/console_appender.cpp

@@ -127,6 +127,9 @@ namespace fc {
       // use now() instead of context.get_timestamp() because log_message construction can include user provided long running calls
       line += string( time_point::now() ); line += ' ';
       line += fixed_size(  9, context.get_thread_name() ); line += ' ';
+#ifdef __linux__
+      line += fixed_size(  9, fc::to_string( context.get_thread_pid() ) ); line += ' ';
+#endif
       line += fixed_size( 29, file_line ); line += ' ';
 
       auto me = context.get_method();

src/log/gelf_appender.cpp

@@ -148,6 +148,9 @@ namespace fc
     gelf_message["_file"] = context.get_file();
     gelf_message["_method_name"] = context.get_method();
     gelf_message["_thread_name"] = context.get_thread_name();
+#ifdef __linux__
+    gelf_message["_thread_pid"] = context.get_thread_pid();
+#endif
     if (!context.get_task_name().empty())
       gelf_message["_task_name"] = context.get_task_name();
 

src/log/log_message.cpp

@@ -8,6 +8,7 @@
 namespace fc
 {
    const string& get_thread_name();
+   const pid_t& get_thread_pid();
    namespace detail
    {
       class log_context_impl
@@ -18,6 +19,7 @@ namespace fc
             uint64_t     line;
             string       method;
             string       thread_name;
+            pid_t        thread_pid;
             string       task_name;
             string       hostname;
             string       context;
@@ -52,6 +54,7 @@ namespace fc
       my->method      = method;
       my->timestamp   = time_point::now();
       my->thread_name = fc::get_thread_name();
+      my->thread_pid  = fc::get_thread_pid();
    }
 
    log_context::log_context( const variant& v )
@@ -64,6 +67,7 @@ namespace fc
        my->method       = obj["method"].as_string();
        my->hostname     = obj["hostname"].as_string();
        my->thread_name  = obj["thread_name"].as_string();
+       my->thread_pid   = obj["thread_pid"].as_int64();
        if (obj.contains("task_name"))
          my->task_name    = obj["task_name"].as_string();
        my->timestamp    = obj["timestamp"].as<time_point>();
@@ -73,7 +77,11 @@ namespace fc
 
    fc::string log_context::to_string()const
    {
+#ifdef __linux__
+      return my->thread_name + " " + fc::to_string(my->thread_pid) + "  " + my->file + ":" + fc::to_string(my->line) + " " + my->method;
+#else
       return my->thread_name + "  " + my->file + ":" + fc::to_string(my->line) + " " + my->method;
+#endif
 
    }
 
@@ -168,6 +176,7 @@ namespace fc
    uint64_t   log_context::get_line_number()const { return my->line; }
    string     log_context::get_method()const     { return my->method; }
    string     log_context::get_thread_name()const { return my->thread_name; }
+   pid_t      log_context::get_thread_pid()const   { return my->thread_pid; }
    string     log_context::get_task_name()const { return my->task_name; }
    string     log_context::get_host_name()const   { return my->hostname; }
    time_point  log_context::get_timestamp()const  { return my->timestamp; }
@@ -184,6 +193,7 @@ namespace fc
                ( "method",       my->method              )
                ( "hostname",     my->hostname            )
                ( "thread_name",  my->thread_name         )
+               ( "thread_pid",   my->thread_pid          )
                ( "timestamp",    variant(my->timestamp)  );
 
       if( my->context.size() ) 

src/log/logger_config.cpp

@@ -8,6 +8,9 @@
 #include <fc/log/gelf_appender.hpp>
 #include <fc/reflect/variant.hpp>
 #include <fc/exception/exception.hpp>
+#ifdef __linux__ 
+#include <sys/syscall.h>
+#endif
 
 namespace fc {
    extern std::unordered_map<std::string,logger>& get_logger_map();
@@ -95,4 +98,19 @@ namespace fc {
          thread_name = string("thread-")+fc::to_string(thread_count++);
       return thread_name;
    }
+
+   static thread_local pid_t thread_pid = 0;
+   void set_thread_pid( const pid_t& pid ) {
+      thread_pid = pid;
+   }
+   const pid_t& get_thread_pid() {
+      if( thread_pid == 0 ) {
+#ifdef __linux__
+         thread_pid = syscall(SYS_gettid);
+#else
+         thread_pid = -ENOSYS;
+#endif
+      }
+      return thread_pid;
+   }
 }