fix console TILE_FATAL to stderr

.gitignore

@@ -2,3 +2,4 @@ out/
 build/
 .cache/
 compile_commands.json
+.gdb_history

CMakeLists.txt

@@ -167,7 +167,7 @@ set(TILE_SRCS
     "tile/base/internal/thread_pool.cc"
     "tile/base/internal/time_keeper.cc"
     "tile/base/internal/time_keeper.h"
-    # logging
+    "tile/base/logging/basic_file_sink.cc"
     "tile/base/logging/splitter_sink.cc"
     "tile/base/logging/console_sink.cc"
     "tile/base/net/endpoint.cc"

tile/base/internal/logging.cc

@@ -84,7 +84,7 @@ public:
     }
 
     num_chars_to_log_ = stream_.pcount();
-    bool append_newline = message_text_[num_chars_to_log_ - 1] != '\n';
+    const bool append_newline = message_text_[num_chars_to_log_ - 1] != '\n';
     char original_final_char = '\0';
 
     if (append_newline) {
@@ -99,7 +99,7 @@ public:
       ++g_num_messages[severity_];
       WaitForSinks();
       if (sink_) {
-        sink_->WaitTillSent();
+        sink_->Flush();
       }
     }
 
@@ -141,18 +141,19 @@ private:
 
   void SendToSink() {
     if (sink_) {
-      sink_->send(severity_, fullname(), basename(), line(), time(),
+      sink_->Send(severity_, fullname(), basename(), line(), time(),
                   message_text_ + num_prefix_chars_,
-                  num_chars_to_log_ - num_prefix_chars_ - 1);
+                  num_chars_to_log_ - num_prefix_chars_);
     }
   }
   void SendToLog() {
     if (g_sink_count.load(std::memory_order_relaxed) == 0) {
-      ColoredWriteToStdout(severity_, message_text_, num_chars_to_log_);
+      ColoredWriteToStdout(severity_, message_text_ + num_prefix_chars_,
+                           num_chars_to_log_ - num_chars_to_log_);
     }
     LogToSinks(severity_, fullname(), basename(), line(), time(),
                message_text_ + num_prefix_chars_,
-               num_chars_to_log_ - num_prefix_chars_ - 1);
+               num_chars_to_log_ - num_prefix_chars_);
   }
   void SendToSinkAndLog() {
     SendToSink();
@@ -278,14 +279,15 @@ void LogMessageTime::CalcGmtOffset() {
 }
 
 LogSink::~LogSink() {}
-void LogSink::send(LogSeverity severity, const char *full_filename,
+bool LogSink::ShouldLog(LogSeverity severity) { return true; }
+void LogSink::Send(LogSeverity severity, const char *full_filename,
                    const char *base_filename, int line,
                    const LogMessageTime &logmsgtime, const char *message,
                    size_t message_len) {
 
   // do nothing
 }
-void LogSink::WaitTillSent() {}
+void LogSink::Flush() {}
 
 std::string LogSink::ToString(LogSeverity severity, const char *file,
                               const char *base_filename, int line,
@@ -356,14 +358,16 @@ void LogToSinks(LogSeverity severity, const char *full_filename,
                 const char *message, size_t message_len) {
   std::lock_guard<std::mutex> _(g_sink_mutex);
   for (auto &&sink : g_sinks) {
-    sink->send(severity, full_filename, base_filename, line, time, message,
-               message_len);
+    if (sink->ShouldLog(severity)) {
+      sink->Send(severity, full_filename, base_filename, line, time, message,
+                 message_len);
+    }
   }
 }
 void WaitForSinks() {
   std::lock_guard<std::mutex> _(g_sink_mutex);
   for (auto &&sink : g_sinks) {
-    sink->WaitTillSent();
+    sink->Flush();
   }
 }
 

tile/base/internal/logging.h

@@ -700,16 +700,16 @@ public:
   using Ptr = std::shared_ptr<LogSink>;
 
   virtual ~LogSink();
-  virtual void send(LogSeverity severity, const char *full_filename,
+  virtual bool ShouldLog(LogSeverity severity);
+  virtual void Send(LogSeverity severity, const char *full_filename,
                     const char *base_filename, int line,
                     const LogMessageTime &logmsgtime, const char *message,
                     size_t message_len);
-  virtual void WaitTillSent();
-
-  virtual std::string ToString(LogSeverity severity, const char *file,
-                               const char *base_filename, int line,
-                               const LogMessageTime &logmsgtime,
-                               const char *message, size_t message_len);
+  virtual void Flush();
+  std::string ToString(LogSeverity severity, const char *file,
+                       const char *base_file, int line,
+                       const LogMessageTime &logmsgtime, const char *message,
+                       size_t message_len);
 };
 
 void ColoredWriteToStdout(LogSeverity severity, const char *message,

tile/base/internal/logging_test.cc

@@ -9,11 +9,11 @@
 #include <thread>
 
 struct AwesomeLogSink : public tile::LogSink {
-  virtual void send(tile::LogSeverity severity, const char *full_filename,
+  virtual void Send(tile::LogSeverity severity, const char *full_filename,
                     const char *base_filename, int line,
                     const tile::LogMessageTime &logmsgtime, const char *message,
                     size_t message_len) override {
-    msgs.emplace_back(message, message_len);
+    msgs.emplace_back(std::string(message, message_len));
   }
   std::vector<std::string> msgs;
 };

tile/base/logging.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include "tile/base/internal/logging.h"
+#include "tile/base/logging/basic_file_sink.h"
 #include "tile/base/logging/splitter_sink.h"
 
 // #define TILE_VLOG(n, ...)

tile/base/logging/basic_file_sink.cc

@@ -0,0 +1,24 @@
+#include "tile/base/logging/basic_file_sink.h"
+
+namespace tile {
+BasicFileSink::Ptr BasicFileSink::Create(const std::string &filepath) {
+  auto sink = std::shared_ptr<BasicFileSink>(new BasicFileSink());
+  sink->set_filepath(filepath);
+  return sink;
+}
+BasicFileSink::BasicFileSink() {}
+BasicFileSink::~BasicFileSink() {}
+void BasicFileSink::Send(LogSeverity severity, const char *full_filename,
+                         const char *base_filename, int line,
+                         const LogMessageTime &logmsgtime, const char *message,
+                         size_t message_len) {
+  TILE_CHECK(!filepath_.empty(), "filepath is empty");
+  ofs_ << std::string(message, message_len) << std::endl;
+}
+std::string BasicFileSink::filepath() const { return filepath_; }
+void BasicFileSink::set_filepath(const std::string &filepath) {
+  filepath_ = filepath;
+  ofs_.open(filepath, std::ios::out | std::ios::app);
+}
+void BasicFileSink::Flush() { ofs_.flush(); }
+} // namespace tile

tile/base/logging/basic_file_sink.h

@@ -0,0 +1,36 @@
+#ifndef TILE_BASE_LOGGING_BASIC_FILE_SINK_H
+#define TILE_BASE_LOGGING_BASIC_FILE_SINK_H
+
+#pragma once
+#include "tile/base/internal/logging.h"
+
+#include <mutex>
+#include <set>
+
+namespace tile {
+class BasicFileSink : public LogSink {
+public:
+  using Ptr = std::shared_ptr<BasicFileSink>;
+  static Ptr Create(const std::string &filepath);
+
+  ~BasicFileSink() override;
+  void Send(LogSeverity severity, const char *full_filename,
+            const char *base_filename, int line,
+            const LogMessageTime &logmsgtime, const char *message,
+            size_t message_len) override;
+  void Flush() override;
+
+  std::string filepath() const;
+  void set_filepath(const std::string &filepath);
+
+protected:
+  BasicFileSink();
+
+private:
+  std::string filepath_;
+  std::ofstream ofs_;
+};
+
+} // namespace tile
+
+#endif // TILE_BASE_LOGGING_BASIC_FILE_SINK_H

tile/base/logging/console_sink.cc

@@ -9,19 +9,23 @@ ConsoleSink::Ptr ConsoleSink::Create() {
 
 ConsoleSink::~ConsoleSink() {}
 
-void ConsoleSink::send(LogSeverity severity, const char *full_filename,
+void ConsoleSink::Send(LogSeverity severity, const char *full_filename,
                        const char *base_filename, int line,
                        const LogMessageTime &logmsgtime, const char *message,
                        size_t message_len) {
   auto msg = ToString(severity, full_filename, base_filename, line, logmsgtime,
                       message, message_len);
   while (!msg.empty() && msg.back() == '\n') {
+    msg.pop_back();
+  }
+  if (severity >= TILE_FATAL) {
+    fprintf(stderr, "%s\n", msg.c_str());
+  } else {
+    fprintf(stdout, "%s\n", msg.c_str());
   }
-  msg.pop_back();
-  fprintf(stdout, "%s\n", msg.c_str());
 }
 
-void ConsoleSink::WaitTillSent() {}
+void ConsoleSink::Flush() {}
 
 ConsoleSink::ConsoleSink() {}
 

tile/base/logging/console_sink.h

@@ -11,11 +11,11 @@ public:
   static Ptr Create();
 
   ~ConsoleSink() override;
-  void send(LogSeverity severity, const char *full_filename,
+  void Send(LogSeverity severity, const char *full_filename,
             const char *base_filename, int line,
             const LogMessageTime &logmsgtime, const char *message,
             size_t message_len) override;
-  void WaitTillSent() override;
+  void Flush() override;
 
 protected:
   ConsoleSink();

tile/base/logging/splitter_sink.cc

@@ -17,7 +17,7 @@ std::shared_ptr<SplitterSink> SplitterSink::Create(
 
 SplitterSink::SplitterSink() {}
 SplitterSink::~SplitterSink() {}
-void SplitterSink::send(LogSeverity severity, const char *full_filename,
+void SplitterSink::Send(LogSeverity severity, const char *full_filename,
                         const char *base_filename, int line,
                         const LogMessageTime &logmsgtime, const char *message,
                         size_t message_len) {
@@ -25,18 +25,18 @@ void SplitterSink::send(LogSeverity severity, const char *full_filename,
   std::lock_guard<std::mutex> _(sinks_mutex_);
   doing_ = true;
   for (auto &sink : sinks_) {
-    sink->send(severity, full_filename, base_filename, line, logmsgtime,
+    sink->Send(severity, full_filename, base_filename, line, logmsgtime,
                message, message_len);
   }
   doing_ = false;
 }
 
-void SplitterSink::WaitTillSent() {
+void SplitterSink::Flush() {
   assert(!doing_ && "SplitterSink::send() should not be called recursively");
   std::lock_guard<std::mutex> _(sinks_mutex_);
   doing_ = true;
   for (auto &sink : sinks_) {
-    sink->WaitTillSent();
+    sink->Flush();
   }
   doing_ = false;
 }

tile/base/logging/splitter_sink.h

@@ -1,3 +1,7 @@
+#ifndef TILE_BASE_LOGGING_SPLITTER_SINK_H
+#define TILE_BASE_LOGGING_SPLITTER_SINK_H
+
+#pragma once
 #include "tile/base/internal/logging.h"
 
 #include <mutex>
@@ -12,11 +16,11 @@ public:
 
   ~SplitterSink() override;
 
-  void send(LogSeverity severity, const char *full_filename,
+  void Send(LogSeverity severity, const char *full_filename,
             const char *base_filename, int line,
             const LogMessageTime &logmsgtime, const char *message,
             size_t message_len) override;
-  void WaitTillSent() override;
+  void Flush() override;
 
   void AddSink(std::shared_ptr<LogSink> sink);
   void RemoveSink(std::shared_ptr<LogSink> sink);
@@ -32,3 +36,5 @@ private:
   bool doing_ = false;
 };
 } // namespace tile
+
+#endif // TILE_BASE_LOGGING_SPLITTER_SINK_H

tile/base/logging/splitter_sink_test.cc

@@ -6,20 +6,20 @@ class SimpleSink : public LogSink {
 public:
   using Ptr = std::shared_ptr<SimpleSink>;
   static Ptr Create() { return std::shared_ptr<SimpleSink>(new SimpleSink()); }
-  void send(LogSeverity severity, const char *full_filename,
+  void Send(LogSeverity severity, const char *full_filename,
             const char *base_filename, int line,
             const LogMessageTime &logmsgtime, const char *message,
             size_t message_len) override {
     message_ = std::string(message, message_len);
   }
-  void WaitTillSent() override {}
+  void Flush() override {}
   std::string message_;
 };
 
 TEST(SplitterSink, One) {
   auto sink = SimpleSink::Create();
   auto splitter = SplitterSink::Create({sink});
-  splitter->send(LogSeverity::TILE_INFO, nullptr, nullptr, 0, LogMessageTime(),
+  splitter->Send(LogSeverity::TILE_INFO, nullptr, nullptr, 0, LogMessageTime(),
                  "message", 7);
   ASSERT_EQ(sink->message_, "message");
 }
@@ -28,7 +28,7 @@ TEST(SplitterSink, Two) {
   auto sink1 = SimpleSink::Create();
   auto sink2 = SimpleSink::Create();
   auto splitter = SplitterSink::Create({sink1, sink2});
-  splitter->send(LogSeverity::TILE_INFO, nullptr, nullptr, 0, LogMessageTime(),
+  splitter->Send(LogSeverity::TILE_INFO, nullptr, nullptr, 0, LogMessageTime(),
                  "message", 7);
   ASSERT_EQ(sink1->message_, "message");
   ASSERT_EQ(sink2->message_, "message");
@@ -44,7 +44,7 @@ TEST(SplitterSink, Multi) {
     std::stringstream ss;
     ss << "message" << i;
     auto msg = ss.str();
-    splitter->send(LogSeverity::TILE_INFO, nullptr, nullptr, 0,
+    splitter->Send(LogSeverity::TILE_INFO, nullptr, nullptr, 0,
                    LogMessageTime(), msg.data(), msg.size());
 
     for (auto &sink : splitter->sinks()) {