| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef _LOG4CXX_ASYNC_APPENDER_H |
| #define _LOG4CXX_ASYNC_APPENDER_H |
| |
| #if defined(_MSC_VER) |
| #pragma warning ( push ) |
| #pragma warning ( disable: 4231 4251 4275 4786 ) |
| #endif |
| |
| |
| #include <log4cxx/appenderskeleton.h> |
| #include <log4cxx/helpers/appenderattachableimpl.h> |
| #include <deque> |
| #include <log4cxx/spi/loggingevent.h> |
| #include <log4cxx/helpers/thread.h> |
| #include <log4cxx/helpers/mutex.h> |
| #include <log4cxx/helpers/condition.h> |
| |
| #if defined(NON_BLOCKING) |
| #include <boost/lockfree/queue.hpp> |
| #endif |
| |
| namespace log4cxx |
| { |
| LOG4CXX_LIST_DEF(LoggingEventList, log4cxx::spi::LoggingEventPtr); |
| |
| /** |
| The AsyncAppender lets users log events asynchronously. It uses a |
| bounded buffer to store logging events. |
| |
| <p>The AsyncAppender will collect the events sent to it and then |
| dispatch them to all the appenders that are attached to it. You can |
| attach multiple appenders to an AsyncAppender. |
| |
| <p>The AsyncAppender uses a separate thread to serve the events in |
| its bounded buffer. |
| |
| <p><b>Important note:</b> The <code>AsyncAppender</code> can only |
| be script configured using the {@link xml::DOMConfigurator DOMConfigurator}. |
| */ |
| class LOG4CXX_EXPORT AsyncAppender : |
| public virtual spi::AppenderAttachable, |
| public virtual AppenderSkeleton |
| { |
| public: |
| DECLARE_LOG4CXX_OBJECT(AsyncAppender) |
| BEGIN_LOG4CXX_CAST_MAP() |
| LOG4CXX_CAST_ENTRY(AsyncAppender) |
| LOG4CXX_CAST_ENTRY_CHAIN(AppenderSkeleton) |
| LOG4CXX_CAST_ENTRY(spi::AppenderAttachable) |
| END_LOG4CXX_CAST_MAP() |
| |
| /** |
| * Create new instance. |
| */ |
| AsyncAppender(); |
| |
| /** |
| * Destructor. |
| */ |
| virtual ~AsyncAppender(); |
| |
| void addRef() const; |
| void releaseRef() const; |
| |
| /** |
| * Add appender. |
| * |
| * @param newAppender appender to add, may not be null. |
| */ |
| void addAppender(const AppenderPtr& newAppender); |
| |
| virtual void doAppend(const spi::LoggingEventPtr& event, |
| log4cxx::helpers::Pool& pool1); |
| |
| void append(const spi::LoggingEventPtr& event, log4cxx::helpers::Pool& p); |
| |
| /** |
| Close this <code>AsyncAppender</code> by interrupting the |
| dispatcher thread which will process all pending events before |
| exiting. |
| */ |
| void close(); |
| |
| /** |
| * Get iterator over attached appenders. |
| * @return list of all attached appenders. |
| */ |
| AppenderList getAllAppenders() const; |
| |
| /** |
| * Get appender by name. |
| * |
| * @param name name, may not be null. |
| * @return matching appender or null. |
| */ |
| AppenderPtr getAppender(const LogString& name) const; |
| |
| /** |
| * Gets whether the location of the logging request call |
| * should be captured. |
| * |
| * @return the current value of the <b>LocationInfo</b> option. |
| */ |
| bool getLocationInfo() const; |
| /** |
| * Determines if specified appender is attached. |
| * @param appender appender. |
| * @return true if attached. |
| */ |
| bool isAttached(const AppenderPtr& appender) const; |
| |
| virtual bool requiresLayout() const; |
| |
| /** |
| * Removes and closes all attached appenders. |
| */ |
| void removeAllAppenders(); |
| |
| /** |
| * Removes an appender. |
| * @param appender appender to remove. |
| */ |
| void removeAppender(const AppenderPtr& appender); |
| /** |
| * Remove appender by name. |
| * @param name name. |
| */ |
| void removeAppender(const LogString& name); |
| |
| /** |
| * The <b>LocationInfo</b> attribute is provided for compatibility |
| * with log4j and has no effect on the log output. |
| * @param flag new value. |
| */ |
| void setLocationInfo(bool flag); |
| |
| /** |
| * The <b>BufferSize</b> option takes a non-negative integer value. |
| * This integer value determines the maximum size of the bounded |
| * buffer. |
| * */ |
| void setBufferSize(int size); |
| |
| /** |
| * Gets the current buffer size. |
| * @return the current value of the <b>BufferSize</b> option. |
| */ |
| int getBufferSize() const; |
| |
| /** |
| * Sets whether appender should wait if there is no |
| * space available in the event buffer or immediately return. |
| * |
| * @param value true if appender should wait until available space in buffer. |
| */ |
| void setBlocking(bool value); |
| |
| /** |
| * Gets whether appender should block calling thread when buffer is full. |
| * If false, messages will be counted by logger and a summary |
| * message appended after the contents of the buffer have been appended. |
| * |
| * @return true if calling thread will be blocked when buffer is full. |
| */ |
| bool getBlocking() const; |
| |
| |
| /** |
| * Set appender properties by name. |
| * @param option property name. |
| * @param value property value. |
| */ |
| void setOption(const LogString& option, const LogString& value); |
| |
| |
| private: |
| AsyncAppender(const AsyncAppender&); |
| AsyncAppender& operator=(const AsyncAppender&); |
| /** |
| * The default buffer size is set to 128 events. |
| */ |
| enum { DEFAULT_BUFFER_SIZE = 128 }; |
| |
| /** |
| * Event buffer. |
| */ |
| #if defined(NON_BLOCKING) |
| boost::lockfree::queue<log4cxx::spi::LoggingEvent* > buffer; |
| std::atomic<size_t> discardedCount; |
| #else |
| LoggingEventList buffer; |
| #endif |
| |
| /** |
| * Mutex used to guard access to buffer and discardMap. |
| */ |
| SHARED_MUTEX bufferMutex; |
| |
| #if defined(NON_BLOCKING) |
| ::log4cxx::helpers::Semaphore bufferNotFull; |
| ::log4cxx::helpers::Semaphore bufferNotEmpty; |
| #else |
| ::log4cxx::helpers::Condition bufferNotFull; |
| ::log4cxx::helpers::Condition bufferNotEmpty; |
| #endif |
| class DiscardSummary |
| { |
| private: |
| /** |
| * First event of the highest severity. |
| */ |
| ::log4cxx::spi::LoggingEventPtr maxEvent; |
| |
| /** |
| * Total count of messages discarded. |
| */ |
| int count; |
| |
| public: |
| /** |
| * Create new instance. |
| * |
| * @param event event, may not be null. |
| */ |
| DiscardSummary(const ::log4cxx::spi::LoggingEventPtr& event); |
| /** Copy constructor. */ |
| DiscardSummary(const DiscardSummary& src); |
| /** Assignment operator. */ |
| DiscardSummary& operator=(const DiscardSummary& src); |
| |
| /** |
| * Add discarded event to summary. |
| * |
| * @param event event, may not be null. |
| */ |
| void add(const ::log4cxx::spi::LoggingEventPtr& event); |
| |
| /** |
| * Create event with summary information. |
| * |
| * @return new event. |
| */ |
| ::log4cxx::spi::LoggingEventPtr createEvent(::log4cxx::helpers::Pool& p); |
| |
| static |
| ::log4cxx::spi::LoggingEventPtr createEvent(::log4cxx::helpers::Pool& p, |
| size_t discardedCount); |
| }; |
| |
| /** |
| * Map of DiscardSummary objects keyed by logger name. |
| */ |
| typedef std::map<LogString, DiscardSummary> DiscardMap; |
| DiscardMap* discardMap; |
| |
| /** |
| * Buffer size. |
| */ |
| int bufferSize; |
| |
| /** |
| * Nested appenders. |
| */ |
| helpers::AppenderAttachableImplPtr appenders; |
| |
| /** |
| * Dispatcher. |
| */ |
| helpers::Thread dispatcher; |
| |
| /** |
| * Should location info be included in dispatched messages. |
| */ |
| bool locationInfo; |
| |
| /** |
| * Does appender block when buffer is full. |
| */ |
| bool blocking; |
| |
| /** |
| * Dispatch routine. |
| */ |
| static void* LOG4CXX_THREAD_FUNC dispatch(apr_thread_t* thread, void* data); |
| |
| }; // class AsyncAppender |
| LOG4CXX_PTR_DEF(AsyncAppender); |
| } // namespace log4cxx |
| |
| #if defined(_MSC_VER) |
| #pragma warning ( pop ) |
| #endif |
| |
| |
| #endif// _LOG4CXX_ASYNC_APPENDER_H |
| |