folly/experimental/logging/LogCategory.cpp

   1 /*
   2  * Copyright 2004-present Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 #include <folly/experimental/logging/LogCategory.h>
  17
  18 #include <cstdio>
  19
  20 #include <folly/ExceptionString.h>
  21 #include <folly/experimental/logging/LogHandler.h>
  22 #include <folly/experimental/logging/LogMessage.h>
  23 #include <folly/experimental/logging/LogName.h>
  24 #include <folly/experimental/logging/LoggerDB.h>
  25
  26 namespace folly {
  27
  28 LogCategory::LogCategory(LoggerDB* db)
  29     : effectiveLevel_{LogLevel::ERROR},
  30       level_{static_cast<uint32_t>(LogLevel::ERROR)},
  31       parent_{nullptr},
  32       name_{},
  33       db_{db} {}
  34
  35 LogCategory::LogCategory(StringPiece name, LogCategory* parent)
  36     : effectiveLevel_{parent->getEffectiveLevel()},
  37       level_{static_cast<uint32_t>(LogLevel::MAX_LEVEL) | FLAG_INHERIT},
  38       parent_{parent},
  39       name_{LogName::canonicalize(name)},
  40       db_{parent->getDB()},
  41       nextSibling_{parent_->firstChild_} {
  42   parent_->firstChild_ = this;
  43 }
  44
  45 void LogCategory::processMessage(const LogMessage& message) const {
  46   // Make a copy of any attached LogHandlers, so we can release the handlers_
  47   // lock before holding them.
  48   //
  49   // In the common case there will only be a small number of handlers.  Use a
  50   // std::array in this case to avoid a heap allocation for the vector.
  51   const std::shared_ptr<LogHandler>* handlers = nullptr;
  52   size_t numHandlers = 0;
  53   constexpr uint32_t kSmallOptimizationSize = 5;
  54   std::array<std::shared_ptr<LogHandler>, kSmallOptimizationSize> handlersArray;
  55   std::vector<std::shared_ptr<LogHandler>> handlersVector;
  56   {
  57     auto lockedHandlers = handlers_.rlock();
  58     numHandlers = lockedHandlers->size();
  59     if (numHandlers <= kSmallOptimizationSize) {
  60       for (size_t n = 0; n < numHandlers; ++n) {
  61         handlersArray[n] = (*lockedHandlers)[n];
  62       }
  63       handlers = handlersArray.data();
  64     } else {
  65       handlersVector = *lockedHandlers;
  66       handlers = handlersVector.data();
  67     }
  68   }
  69
  70   for (size_t n = 0; n < numHandlers; ++n) {
  71     try {
  72       handlers[n]->handleMessage(message, this);
  73     } catch (const std::exception& ex) {
  74       // Use LoggerDB::internalWarning() to report the error, but continue
  75       // trying to log the message to any other handlers attached to ourself or
  76       // one of our parent categories.
  77       LoggerDB::internalWarning(
  78           __FILE__,
  79           __LINE__,
  80           "log handler for category \"",
  81           name_,
  82           "\" threw an error: ",
  83           folly::exceptionStr(ex));
  84     }
  85   }
  86
  87   // Propagate the message up to our parent LogCategory.
  88   //
  89   // Maybe in the future it might be worth adding a flag to control if a
  90   // LogCategory should propagate messages to its parent or not.  (This would
  91   // be similar to log4j's "additivity" flag.)
  92   // For now I don't have a strong use case for this.
  93   if (parent_) {
  94     parent_->processMessage(message);
  95   }
  96 }
  97
  98 void LogCategory::addHandler(std::shared_ptr<LogHandler> handler) {
  99   auto handlers = handlers_.wlock();
 100   handlers->emplace_back(std::move(handler));
 101 }
 102
 103 void LogCategory::clearHandlers() {
 104   std::vector<std::shared_ptr<LogHandler>> emptyHandlersList;
 105   // Swap out the handlers list with the handlers_ lock held.
 106   {
 107     auto handlers = handlers_.wlock();
 108     handlers->swap(emptyHandlersList);
 109   }
 110   // Destroy emptyHandlersList now that the handlers_ lock is released.
 111   // This way we don't hold the handlers_ lock while invoking any of the
 112   // LogHandler destructors.
 113 }
 114
 115 std::vector<std::shared_ptr<LogHandler>> LogCategory::getHandlers() const {
 116   return *(handlers_.rlock());
 117 }
 118
 119 void LogCategory::setLevel(LogLevel level, bool inherit) {
 120   // We have to set the level through LoggerDB, since we require holding
 121   // the LoggerDB lock to iterate through our children in case our effective
 122   // level changes.
 123   db_->setLevel(this, level, inherit);
 124 }
 125
 126 void LogCategory::setLevelLocked(LogLevel level, bool inherit) {
 127   // Clamp the value to MIN_LEVEL and MAX_LEVEL.
 128   //
 129   // This makes sure that UNINITIALIZED is always less than any valid level
 130   // value, and that level values cannot conflict with our flag bits.
 131   if (level > LogLevel::MAX_LEVEL) {
 132     level = LogLevel::MAX_LEVEL;
 133   } else if (level < LogLevel::MIN_LEVEL) {
 134     level = LogLevel::MIN_LEVEL;
 135   }
 136
 137   // Make sure the inherit flag is always off for the root logger.
 138   if (!parent_) {
 139     inherit = false;
 140   }
 141   auto newValue = static_cast<uint32_t>(level);
 142   if (inherit) {
 143     newValue |= FLAG_INHERIT;
 144   }
 145
 146   // Update the stored value
 147   uint32_t oldValue = level_.exchange(newValue, std::memory_order_acq_rel);
 148
 149   // Break out early if the value has not changed.
 150   if (oldValue == newValue) {
 151     return;
 152   }
 153
 154   // Update the effective log level
 155   LogLevel newEffectiveLevel;
 156   if (inherit) {
 157     newEffectiveLevel = std::min(level, parent_->getEffectiveLevel());
 158   } else {
 159     newEffectiveLevel = level;
 160   }
 161   updateEffectiveLevel(newEffectiveLevel);
 162 }
 163
 164 void LogCategory::updateEffectiveLevel(LogLevel newEffectiveLevel) {
 165   auto oldEffectiveLevel =
 166       effectiveLevel_.exchange(newEffectiveLevel, std::memory_order_acq_rel);
 167   // Break out early if the value did not change.
 168   if (newEffectiveLevel == oldEffectiveLevel) {
 169     return;
 170   }
 171
 172   // Update all of the values in xlogLevels_
 173   for (auto* levelPtr : xlogLevels_) {
 174     levelPtr->store(newEffectiveLevel, std::memory_order_release);
 175   }
 176
 177   // Update all children loggers
 178   LogCategory* child = firstChild_;
 179   while (child != nullptr) {
 180     child->parentLevelUpdated(newEffectiveLevel);
 181     child = child->nextSibling_;
 182   }
 183 }
 184
 185 void LogCategory::parentLevelUpdated(LogLevel parentEffectiveLevel) {
 186   uint32_t levelValue = level_.load(std::memory_order_acquire);
 187   auto inherit = (levelValue & FLAG_INHERIT);
 188   if (!inherit) {
 189     return;
 190   }
 191
 192   auto myLevel = static_cast<LogLevel>(levelValue & ~FLAG_INHERIT);
 193   auto newEffectiveLevel = std::min(myLevel, parentEffectiveLevel);
 194   updateEffectiveLevel(newEffectiveLevel);
 195 }
 196
 197 void LogCategory::registerXlogLevel(std::atomic<LogLevel>* levelPtr) {
 198   xlogLevels_.push_back(levelPtr);
 199 }
 200 }