Mojo Log service and a thread-safe client library.

mojo/services/log/cpp/lib/log_client.cc

+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "mojo/services/log/cpp/log_client.h"
+
+#include <assert.h>
+
+#include <atomic>
+#include <string>
+#include <utility>
+
+#include "mojo/public/c/environment/logger.h"
+#include "mojo/public/cpp/bindings/interface_ptr_info.h"
+#include "mojo/public/cpp/bindings/lib/message_builder.h"
+#include "mojo/public/cpp/system/message_pipe.h"
+#include "mojo/services/log/interfaces/entry.mojom.h"
+#include "mojo/services/log/interfaces/log.mojom.h"
+
+namespace mojo {
+namespace {
+
+class LogClient;
+
+// Forward declare for constructing |g_logclient_logger|.
+void LogMessage(MojoLogLevel log_level,
+                const char* source_file,
+                uint32_t source_line,
+                const char* message);
+MojoLogLevel GetMinimumLogLevel();
+void SetMinimumLogLevel(MojoLogLevel level);
+
+// This logger is what |GetLogger()| returns, and delegates all of its work to
+// |g_logclient|.
+const MojoLogger g_logclient_logger = {&LogMessage, &GetMinimumLogLevel,
+                                       &SetMinimumLogLevel};
+LogClient* g_log_client = nullptr;
+
+class LogClient {
+ public:
+  LogClient(log::LogPtr log_service, const MojoLogger* fallback_logger);
+
+  void LogMessage(MojoLogLevel log_level,
+                  const char* source_file,
+                  uint32_t source_line,
+                  const char* message);
+
+  MojoLogLevel GetMinimumLogLevel();
+  void SetMinimumLogLevel(MojoLogLevel level);
+
+ private:
+  InterfacePtrInfo<mojo::log::Log> log_interface_;
+  std::atomic<MojoLogLevel> min_loglevel_;
+  const MojoLogger* fallback_logger_;
+};
+
+LogClient::LogClient(log::LogPtr log, const MojoLogger* fallback_logger)
+    : log_interface_(log.PassInterface()),
+      min_loglevel_(MOJO_LOG_LEVEL_INFO),
+      fallback_logger_(fallback_logger) {
+  assert(log_interface_.is_valid());
+  assert(fallback_logger_);
+}
+
+void LogClient::LogMessage(MojoLogLevel log_level,
+                           const char* source_file,
+                           uint32_t source_line,
+                           const char* message) {
+  // We avoid the use of C++ bindings to do interface calls in order to be
+  // thread-safe (as of this writing, the bindings are not).  Because the
+  // AddEntry message of the Log interface does not have a response message, we
+  // can fire-and-forget the message: construct the params for the call, frame
+  // it inside a Message and write the Message to the message pipe connecting to
+  // the log service.
+  if (!log_interface_.is_valid()) {
+    return fallback_logger_->LogMessage(log_level, source_file, source_line,
+                                        message);
+  }
+
+  if (log_level < min_loglevel_.load(std::memory_order_relaxed))
+    return;
+
+  mojo::log::Log_AddEntry_Params request_params;
+  request_params.entry = mojo::log::Entry::New();
+  request_params.entry->timestamp = GetTimeTicksNow();
+  request_params.entry->log_level = log_level;
+  request_params.entry->source_file = source_file;
+  request_params.entry->source_line = source_line;
+  request_params.entry->message = message;
+
+  size_t params_size = request_params.GetSerializedSize();
+  MessageBuilder builder(
+      static_cast<uint32_t>(mojo::log::Log::MessageOrdinals::AddEntry),
+      params_size);
+
+  request_params.Serialize(
+      static_cast<void*>(builder.message()->mutable_payload()), params_size);
+
+  auto retval =
+      WriteMessageRaw(log_interface_.handle().get(), builder.message()->data(),
+                      builder.message()->data_num_bytes(), nullptr, 0,
+                      MOJO_WRITE_MESSAGE_FLAG_NONE);
+  switch (retval) {
+    case MOJO_RESULT_OK:
+      break;
+
+    // TODO(vardhan): Are any of these error cases recoverable (in which case
+    // we shouldn't close our handle)?  Maybe MOJO_RESULT_RESOURCE_EXHAUSTED?
+    case MOJO_RESULT_INVALID_ARGUMENT:
+    case MOJO_RESULT_RESOURCE_EXHAUSTED:
+    case MOJO_RESULT_FAILED_PRECONDITION:
+    case MOJO_RESULT_UNIMPLEMENTED:
+    case MOJO_RESULT_BUSY: {
+      log_interface_.PassHandle();
+      return fallback_logger_->LogMessage(log_level, source_file, source_line,
+                                          message);
+    }
+
+    default:
+      // Should not reach here.
+      assert(false);
+  }
+
+  if (log_level >= MOJO_LOG_LEVEL_FATAL)
+    abort();
+}
+
+MojoLogLevel LogClient::GetMinimumLogLevel() {
+  if (!log_interface_.is_valid())
+    return fallback_logger_->GetMinimumLogLevel();
+
+  return min_loglevel_.load(std::memory_order_relaxed);
+}
+
+// TODO(vardhan): Should we keep the our log level consistent with the fallback
+// logger's? If we do, and we also require the fallback logger be thread-safe,
+// then we could get rid of |g_min_log_level| altogether and use the fallback
+// logger's (Get|Set)MinimumLogLevel functions.
+void LogClient::SetMinimumLogLevel(MojoLogLevel level) {
+  if (!log_interface_.is_valid()) {
+    assert(fallback_logger_);
+    fallback_logger_->SetMinimumLogLevel(level);
+    return;
+  }
+
+  min_loglevel_.store(std::min(level, MOJO_LOG_LEVEL_FATAL),
+                      std::memory_order_relaxed);
+}
+
+void LogMessage(MojoLogLevel log_level,
+                const char* source_file,
+                uint32_t source_line,
+                const char* message) {
+  assert(g_log_client);
+  g_log_client->LogMessage(log_level, source_file, source_line, message);
+}
+
+MojoLogLevel GetMinimumLogLevel() {
+  assert(g_log_client);
+  return g_log_client->GetMinimumLogLevel();
+}
+
+void SetMinimumLogLevel(MojoLogLevel level) {
+  assert(g_log_client);
+  g_log_client->SetMinimumLogLevel(level);
+}
+
+}  // namespace
+
+namespace log {
+
+void InitializeLogger(LogPtr log_service, const MojoLogger* fallback_logger) {
+  assert(!g_log_client);
+  g_log_client = new LogClient(std::move(log_service), fallback_logger);
+}
+
+const MojoLogger* GetLogger() {
+  assert(g_log_client);
+  return &g_logclient_logger;
+}
+
+void DestroyLogger() {
+  assert(g_log_client);
+  delete g_log_client;
+  g_log_client = nullptr;
+}
+
+}  // namespace log
+}  // namespace mojo