UT_UniversalLogInMemorySink.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_UniversalLogInMemorySink.h ( FS Library, C++)
 *
 * COMMENTS:
 *
 */

#ifndef __UT_UniversalLogInMemorySink__
#define __UT_UniversalLogInMemorySink__

#include "UT_API.h"
#include "UT_Lock.h"
#include "UT_SharedPtr.h"
#include "UT_UniversalLogEntry.h"
#include "UT_UniversalLogSink.h"
#include "UT_UniversalLogFileSink.h"
#include <SYS/SYS_Types.h>
#include <SYS/SYS_AtomicInt.h>

class UT_StringRef;

/// This class is a universal log sync which stores all log entries in memory.
/// A maximum memory use threshold can be set, and excess messages are
/// automatically deleted.
class UT_API UT_UniversalLogInMemorySink : public UT_UniversalLogSink
{
public:
                         UT_UniversalLogInMemorySink();
                        ~UT_UniversalLogInMemorySink() override;

    /// Returns the number of log entries currently in memory. An entry may
    /// become "inactive" (i.e. flushed from memory) when this sink reaches
    /// its maximum log count, or if someone steals our log entries.
    exint                activeLogCount();
    /// Returns the number of log entries we have ever seen. It can be useful
    /// to have this monotonically increasing number to look for changes and
    /// insulate from the automated (or manual) purging of log entries.
    exint                allTimeLogCount();
    /// Returns a copy of the log entry at a specific all-time index. If the
    /// index is out of range, or is no longer active, an empty log entry is
    /// returned.
    UT_UniversalLogEntry allTimeLogEntry(exint all_time_idx);
    /// Steals all current log entries into the supplied array. This object
    /// will no longer have any record of these log entries after this call.
    void                 stealLogEntries(UT_UniversalLogEntryArray &log);

protected:
    /// This override stores the log messages in memory.
    void                 doLog(const UT_UniversalLogEntry &entry) override;

    /// Grab messages from the inbound log entries and add them to the
    /// inspectable log entries. This function also enforces the maximum
    /// total message size.
    ///
    /// NOTE: myDataLock MUST be locked before calling this method.
    void                 adoptInboundLogEntries();

    /// The inbound message queue is where events get logged, but messages
    /// on this queue cannot be inspected. We never want the addition of
    /// new messages to be blocked by some (potentially slow) inspection of
    /// the current set of messages.
    UT_Lock                          myInboundDataLock;
    UT_UniversalLogEntryArray        myInboundLogEntries;
    SYS_AtomicCounter                myInboundTotalLogEntriesSize;
    /// These log entries are the ones that have been collected from the
    /// inbound queue. And filtering and sorting happens during this
    /// transition.
    UT_Lock                          myDataLock;
    UT_UniversalLogEntryArray        myLogEntries;
    exint                            myTotalLogEntriesSize;
    exint                            myMaxTotalLogEntriesSize;
    /// A counter that is increased any time a message is added.
    SYS_AtomicCounter                myAllTimeLogCount;
};

#endif