folly/experimental/logging/LogWriter.h

   1 /*
   2  * Copyright 2017-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 #pragma once
  17
  18 #include <folly/Range.h>
  19
  20 namespace folly {
  21
  22 /**
  23  * LogWriter defines the interface for processing a serialized log message.
  24  */
  25 class LogWriter {
  26  public:
  27   /**
  28    * Bit flag values for use with writeMessage()
  29    */
  30   enum Flags : uint32_t {
  31     NO_FLAGS = 0x00,
  32     /**
  33      * Ensure that this log message never gets discarded.
  34      *
  35      * Some LogWriter implementations may discard messages when messages are
  36      * being received faster than they can be written.  This flag ensures that
  37      * this message will never be discarded.
  38      *
  39      * This flag is used to ensure that LOG(FATAL) messages never get
  40      * discarded, so we always report the reason for a crash.
  41      */
  42     NEVER_DISCARD = 0x01,
  43   };
  44
  45   virtual ~LogWriter() {}
  46
  47   /**
  48    * Write a serialized log message.
  49    *
  50    * The flags parameter is a bitwise-ORed set of Flag values defined above.
  51    */
  52   virtual void writeMessage(folly::StringPiece buffer, uint32_t flags = 0) = 0;
  53
  54   /**
  55    * Write a serialized message.
  56    *
  57    * This version of writeMessage() accepts a std::string&&.
  58    * The default implementation calls the StringPiece version of
  59    * writeMessage(), but subclasses may override this implementation if
  60    * desired.
  61    */
  62   virtual void writeMessage(std::string&& buffer, uint32_t flags = 0) {
  63     writeMessage(folly::StringPiece{buffer}, flags);
  64   }
  65
  66   /**
  67    * Block until all messages that have already been sent to this LogWriter
  68    * have been written.
  69    *
  70    * Other threads may still call writeMessage() while flush() is running.
  71    * writeMessage() calls that did not complete before the flush() call started
  72    * will not necessarily be processed by the flush call.
  73    */
  74   virtual void flush() = 0;
  75 };
  76 } // namespace folly