Gimesketvirtadien's time requested changes

src/filesinkhelper.ipp

@@ -81,7 +81,7 @@ namespace g3 {
          //  Day Month Date Time Year: is written as "%a %b %d %H:%M:%S %Y" and formatted output as : Wed Sep 19 08:28:16 2012
          ss_entry << "\t\tg3log created log at: " << g3::localtime_formatted(g3::systemtime_now(), "%a %b %d %H:%M:%S %Y") << "\n";
          ss_entry << "\t\tLOG format: [YYYY/MM/DD hh:mm:ss uuu* LEVEL FILE->FUNCTION:LINE] message";
-         ss_entry << "\t\t(uuu*: microsecond counter since initialization of log worker)\n\n";
+         ss_entry << "\t\t(uuu*: microseconds fractions of the seconds value)\n\n";
          return ss_entry.str();
       }
 

src/g3log.cpp

@@ -117,9 +117,6 @@ namespace g3 {
    }
 
 
-
-
-
    namespace internal {
 
       bool isLoggingInitialized() {

src/g3log/logmessage.hpp

@@ -47,9 +47,6 @@ namespace g3 {
       /// use a different format string to get a different look on the time.
       //  default look is Y/M/D H:M:S
       std::string timestamp(const std::string& time_format = {internal::date_formatted + " " + internal::time_formatted}) const;
-      std::string microseconds() const {
-         return std::to_string(_microseconds);
-      }
 
       std::string message() const  {
          return _message;
@@ -87,9 +84,8 @@ namespace g3 {
       // Complete access to the raw data in case the helper functions above
       // are not enough.
       //
-      std::time_t _timestamp;
+      timespec _timestamp;
       std::thread::id _call_thread_id;
-      int64_t _microseconds;
       std::string _file;
       int _line;
       std::string _function;
@@ -103,7 +99,6 @@ namespace g3 {
          using std::swap;
          swap(first._timestamp, second._timestamp);
          swap(first._call_thread_id, second._call_thread_id);
-         swap(first._microseconds, second._microseconds);
          swap(first._file, second._file);
          swap(first._line, second._line);
          swap(first._function, second._function);
@@ -116,7 +111,6 @@ namespace g3 {
 
 
 
-
    /** Trigger for flushing the message queue and exiting the application
     * A thread that causes a FatalMessage will sleep forever until the
     * application has exited (after message flush) */

src/g3log/time.hpp

@@ -26,15 +26,26 @@ namespace g3
    namespace internal
    {
       static const std::string date_formatted = "%Y/%m/%d";
-      static const std::string time_formatted = "%H:%M:%S";
+      // %f: fractions of seconds (%f is nanoseconds)
+      // %f3: milliseconds, 3 digits: 001
+      // %6: microseconds: 6 digits: 000001  --- default for the time_format
+      // %f9, %f: nanoseconds, 9 digits: 000000001
+      static const std::string time_formatted = "%H:%M:%S %f6";
    }
 
    typedef std::chrono::time_point<std::chrono::system_clock>  system_time_point;
    typedef std::chrono::milliseconds milliseconds;
    typedef std::chrono::microseconds microseconds;
 
+   size_t time_fraction(const std::string& format_buffer, size_t pos);
+
    //  wrap for std::chrono::system_clock::now()
    std::time_t systemtime_now();
+
+   // OSX, Windows needed wrapper for std::timespec_get(struct timespec *ts, int base)
+   //   OSX and Windows also lacks the POSIX clock_gettime(int base, struct timespec *ts)
+   //   so for that reason we go with the std::timespec_get(...) but wrap it
+   int timespec_get(struct timespec *ts/*, int base*/);
 
    /** return time representing POD struct (ref ctime + wchar) that is normally
    * retrieved with std::localtime. g3::localtime is threadsafe which std::localtime is not.
@@ -45,6 +56,7 @@ namespace g3
    * WARNING: At time of writing there is only so-so compiler support for
    * std::put_time. A possible fix if your c++11 library is not updated is to
    * modify this to use std::strftime instead */
+   std::string localtime_formatted(const timespec &time_snapshot, const std::string &time_format) ;
    std::string localtime_formatted(const std::time_t &time_snapshot, const std::string &time_format) ;
 }
 

src/logmessage.cpp

@@ -12,17 +12,6 @@
 #include <mutex>
 
 namespace {
-   std::once_flag g_start_time_flag;
-   std::chrono::steady_clock::time_point g_start_time;
-
-   int64_t  microsecondsCounter() {
-      std::call_once(g_start_time_flag, []() {
-         g_start_time = std::chrono::steady_clock::now();
-      });
-      auto  now = std::chrono::steady_clock::now();
-      return std::chrono::duration_cast<std::chrono::microseconds>(now - g_start_time).count();
-   }
-
    std::string splitFileName(const std::string& str) {
       size_t found;
       found = str.find_last_of("(/\\");
@@ -38,7 +27,7 @@ namespace g3 {
    // helper for setting the normal log details in an entry
    std::string LogDetailsToString(const LogMessage& msg) {
       std::string out;
-      out.append("\n" + msg.timestamp() + " " + msg.microseconds() +  "\t"
+      out.append("\n" + msg.timestamp() + "\t"
                  + msg.level() + " [" + msg.file() + "->" + msg.function() + ":" + msg.line() + "]\t");
       return out;
    }
@@ -54,7 +43,7 @@ namespace g3 {
    // helper for fatal signal
    std::string  fatalSignalToString(const LogMessage& msg) {
       std::string out; // clear any previous text and formatting
-      out.append("\n" + msg.timestamp() + "." + msg.microseconds()
+      out.append("\n" + msg.timestamp()
                  + "\n\n***** FATAL SIGNAL RECEIVED ******* \n"
                  + '"' + msg.message() + '"');
       return out;
@@ -64,7 +53,7 @@ namespace g3 {
    // helper for fatal exception (windows only)
    std::string  fatalExceptionToString(const LogMessage& msg) {
       std::string out; // clear any previous text and formatting
-      out.append("\n" + msg.timestamp() + "." + msg.microseconds()
+      out.append("\n" + msg.timestamp()
                  + "\n\n***** FATAL EXCEPTION RECEIVED ******* \n"
                  + '"' + msg.message() + '"');
       return out;
@@ -122,7 +111,7 @@ namespace g3 {
 
 
    std::string LogMessage::timestamp(const std::string& time_look) const {
-      return  localtime_formatted(_timestamp, time_look);
+      return g3::localtime_formatted(_timestamp, time_look);
    }
 
 
@@ -136,14 +125,17 @@ namespace g3 {
 
    LogMessage::LogMessage(const std::string& file, const int line,
                           const std::string& function, const LEVELS& level)
-      : _timestamp(g3::systemtime_now())
-      , _call_thread_id(std::this_thread::get_id())
-      , _microseconds(microsecondsCounter())
+      : _call_thread_id(std::this_thread::get_id())
       , _file(splitFileName(file))
       , _line(line)
       , _function(function)
       , _level(level)
-   {}
+   {
+      g3::timespec_get(&_timestamp/*, TIME_UTC*/);
+      // Another possibility could be to Falling back to clock_gettime as TIME_UTC 
+      // is not recognized by travis CI. 
+      // i.e. clock_gettime(CLOCK_REALTIME, &_timestamp);
+   }
 
 
    LogMessage::LogMessage(const std::string& fatalOsSignalCrashMessage)
@@ -154,7 +146,6 @@ namespace g3 {
    LogMessage::LogMessage(const LogMessage& other)
       : _timestamp(other._timestamp)
       , _call_thread_id(other._call_thread_id)
-      , _microseconds(other._microseconds)
       , _file(other._file)
       , _line(other._line)
       , _function(other._function)
@@ -166,7 +157,6 @@ namespace g3 {
    LogMessage::LogMessage(LogMessage &&other)
       : _timestamp(other._timestamp)
       , _call_thread_id(other._call_thread_id)
-      , _microseconds(other._microseconds)
       , _file(std::move(other._file))
       , _line(other._line)
       , _function(std::move(other._function))
@@ -183,6 +173,8 @@ namespace g3 {
       return oss.str();
    }
 
+
+
    FatalMessage::FatalMessage(const LogMessage& details, g3::SignalType signal_id)
       : LogMessage(details), _signal_id(signal_id) { }
 

src/time.cpp

@@ -2,17 +2,53 @@
 * 2012 by KjellKod.cc. This is PUBLIC DOMAIN to use at your own risk and comes
 * with no warranties. This code is yours to share, use and modify with no
 * strings attached and no restrictions or obligations.
-* 
+*
 * For more information see g3log/LICENSE or refer refer to http://unlicense.org
 * ============================================================================*/
 
 #include "g3log/time.hpp"
 
 #include <sstream>
 #include <string>
+#include <cstring>
+#include <cmath>
 #include <chrono>
 #include <cassert>
 #include <iomanip>
+#ifdef __MACH__
+#include <sys/time.h>
+#endif
+
+
+namespace {
+   const size_t kMsDigitsToCut = 1000000; // 3 digits left of 1000 000 000
+   const size_t kUsDigitsToCut = 1000; // 6 digits left
+   const size_t kNsDigitsToCut = 1; // all digits left : divide by 1
+   const size_t kNsDefaultDigits = 0;
+   const size_t kDigitIdentifier = 1;
+   const size_t kNoDigitIdentifier = 0;
+
+   const std::string kIdentifier   = "%f";
+   const size_t kIdentifierSize = 2;
+
+
+   std::string fractional_to_string(size_t fractional, size_t cutOffDivider) {
+      auto zeroes = 9; // default ns
+      if (kMsDigitsToCut ==  cutOffDivider) {
+         zeroes = 3;
+      } else if (kUsDigitsToCut == cutOffDivider) {
+         zeroes = 6;
+      } else {
+         cutOffDivider = 1;
+      }
+      fractional /= cutOffDivider;
+
+      // auto value = std::to_string(typeAdjustedValue);
+      // return value; // std::string(fractional_digit, '0') + value;
+      auto value = std::string(std::to_string(fractional));
+      return std::string(zeroes - value.size(), '0') + value;
+   }
+} // anonymous
 
 
 namespace g3 {
@@ -21,21 +57,21 @@ namespace g3 {
       // This is needed since latest version (at time of writing) of gcc4.7 does not implement this library function yet.
       // return value is SIMPLIFIED to only return a std::string
 
-      std::string put_time(const struct tm *tmb, const char *c_time_format) {
+      std::string put_time(const struct tm* tmb, const char* c_time_format) {
 #if (defined(WIN32) || defined(_WIN32) || defined(__WIN32__)) && !defined(__MINGW32__)
          std::ostringstream oss;
          oss.fill('0');
          // BOGUS hack done for VS2012: C++11 non-conformant since it SHOULD take a "const struct tm*  "
-         oss << std::put_time(const_cast<struct tm *> (tmb), c_time_format);
+         oss << std::put_time(const_cast<struct tm*> (tmb), c_time_format);
          return oss.str();
 #else    // LINUX
          const size_t size = 1024;
          char buffer[size]; // IMPORTANT: check now and then for when gcc will implement std::put_time.
          //                    ... also ... This is way more buffer space then we need
 
          auto success = std::strftime(buffer, size, c_time_format, tmb);
-         if (0 == success)
-         {
+         // TODO: incorrect code
+         if (0 == success) {
             assert((0 != success) && "strftime fails with illegal formatting");
             return c_time_format;
          }
@@ -55,7 +91,33 @@ namespace g3 {
       return std::chrono::system_clock::to_time_t(system_now);
    }
 
-   tm localtime(const std::time_t &time) {
+
+   int timespec_get(struct timespec* ts/*, int base*/) {
+#ifdef __MACH__
+      // std::timespec_get or posix clock_gettime)(...) are not
+      // implemented on OSX
+      // @return value of base if successful, else zero
+      struct timeval now = {};
+      int rv = gettimeofday(&now, nullptr);
+      if (-1 == rv) {
+         return rv;
+      }
+      // error mode. just return sec, microsecond
+      ts->tv_sec  = now.tv_sec;
+      ts->tv_nsec = now.tv_usec * 1000;
+      return 0;
+#else
+      // Linux
+      return std::timespec_get(ts, TIME_UTC));
+#endif
+   }
+
+
+
+
+
+
+   tm localtime(const std::time_t& time) {
       struct tm tm_snapshot;
 #if (defined(WIN32) || defined(_WIN32) || defined(__WIN32__) && !defined(__GNUC__))
       localtime_s(&tm_snapshot, &time); // windsows
@@ -65,11 +127,40 @@ namespace g3 {
       return tm_snapshot;
    }
 
-   /// returns a std::string with content of time_t as localtime formatted by input format string
-   /// * format string must conform to std::put_time
-   /// This is similar to std::put_time(std::localtime(std::time_t*), time_format.c_str());
 
-   std::string localtime_formatted(const std::time_t &time_snapshot, const std::string &time_format) {
+
+   size_t fractional_cutoff(const std::string& format_buffer, size_t pos) {
+      char  ch  = (format_buffer.size() > pos + kIdentifierSize ? format_buffer.at(pos + kIdentifierSize) : '\0');
+      size_t cutOff = 0;
+      switch (ch) {
+         case '3': cutOff = kMsDigitsToCut; break;
+         case '6': cutOff = kUsDigitsToCut; break;
+         case '9': cutOff = kNsDigitsToCut; break;
+         default: cutOff = kNsDefaultDigits; break;
+      }
+      return cutOff;
+   }
+
+
+   std::string localtime_formatted(const timespec& time_snapshot, const std::string& time_format) {
+      auto format_buffer = time_format;  // copying format string to a separate buffer
+
+      // iterating through every "%f" instance in the format string
+      auto identifierExtraSize = 0;
+      for (size_t pos = 0; (pos = format_buffer.find(kIdentifier, pos)) != std::string::npos; pos += kIdentifierSize + identifierExtraSize) {
+         // figuring out whether this is nano, micro or milli identifier
+         auto cutoff = fractional_cutoff(format_buffer, pos);
+         auto value = fractional_to_string(time_snapshot.tv_nsec, cutoff);
+         auto identifierExtraSize = cutoff == kNsDefaultDigits ? kNoDigitIdentifier : kDigitIdentifier;
+
+         // replacing "%f[3|6|9]" with sec fractional part value
+         format_buffer.replace(pos, kIdentifier.size() + identifierExtraSize, value);
+      }
+
+      return localtime_formatted(time_snapshot.tv_sec, format_buffer);
+   }
+
+   std::string localtime_formatted(const std::time_t& time_snapshot, const std::string& time_format) {
       std::tm t = localtime(time_snapshot); // could be const, but cannot due to VS2012 is non conformant for C++11's std::put_time (see above)
       return g3::internal::put_time(&t, time_format.c_str()); // format example: //"%Y/%m/%d %H:%M:%S");
    }