loggingLoggingProxy.h

Go to the documentation of this file.

#ifndef logging_logging_proxy_H
#define logging_logging_proxy_H

/*******************************************************************************
 *    ALMA - Atacama Large Millimiter Array
 *    (c) European Southern Observatory, 2002
 *    Copyright by ESO (in the framework of the ALMA collaboration)
 *    and Cosylab 2002, All rights reserved
 *
 *    This library is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation; either
 *    version 2.1 of the License, or (at your option) any later version.
 *
 *    This library is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with this library; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 *
 * "@(#) $Id: loggingLoggingProxy.h,v 1.39 2010/03/15 10:31:03 bjeram Exp $"
 *
 * who       when        what
 * --------  ----------  ----------------------------------------------
 * bjeram    2003-03-06  added #include <ace/Log_Record.h> (needed by ACE/TAO x.3)
 * bjeram    2002-04-10  added setStdio
 * msekoran  2001-12-17  added CL failure detection, logging to syslog, file, ...
 * bjeram    2001-09-13  added logXML(...) method
 * bjeram    2001-08     added ACS_LOG_TIME macro
 * msekoran  2001-07-12  renamed m_data and m_flags variables in LoggingTSSStorage class
 * msekoran  2001-06-08  Implementation according new specifications
 * almamgr   2000-12-03  Removed static and changed to char* from filename and oldfilename
 * almamgr   2000-12-03  created
 */

#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif

#include <ace/Log_Msg_Callback.h>

#include <deque>

#include <orbsvcs/orbsvcs/DsLogAdminC.h>
#include <orbsvcs/CosNamingC.h>

#include <ace/Synch.h>
#include "logging_idlC.h"

#include "loggingExport.h"
#include "loggingLoggingTSSStorage.h"

#define DYNAMIC_LOG_LEVEL 1
#define CDB_REFRESH_LOG_LEVEL 2
#define ENV_LOG_LEVEL 3
#define CDB_LOG_LEVEL 4
#define DEFAULT_LOG_LEVEL 5
#define NOT_DEFINED_LOG_LEVEL 6

#define ADD_DATA_VALUE_MAX 1024

#define ADD_DATA_NAME_MAX 256

#define LM_RUNTIME_CONTEXT 0x00000200

#define LM_SOURCE_INFO 0x00000100

#define LM_FULL_INFO (LM_RUNTIME_CONTEXT | LM_SOURCE_INFO)

class logging_EXPORT LoggingProxy : public ACE_Log_Msg_Callback
{

  public:
    void log(ACE_Log_Record &log_record);

    static void LogEntryType(const ACE_TCHAR *szType);

    static void Routine(const ACE_TCHAR *szRoutine);

    static void File(const ACE_TCHAR *fileName);

    static void Line(long lineNumber);

    static void Flags(unsigned int uiFlags);

    static void ThreadName(const ACE_TCHAR *szName);

    static const ACE_TCHAR *ThreadName();

    static void ProcessName(const ACE_TCHAR *szName);

    static const ACE_TCHAR *ProcessName();

    static void ResetAttributes();

    static void AddAttribute(const ACE_TCHAR *szName, const ACE_TCHAR *szValue);

    static void LogId(const ACE_TCHAR *szName);

    static void URI(const ACE_TCHAR *szName);

    static void StackId(const ACE_TCHAR *szId);

    static const ACE_TCHAR *StackId();

    static void PrivateFlags(int privateFlags);

    static const int PrivateFlags();

    static void LogLevelLocalType(int logLevelLocalType);

    static const int LogLevelLocalType();

    static void LogLevelRemoteType(int logLevelRemoteType);

    static const int LogLevelRemoteType();

    static void StackLevel(int nLevel);

    static int StackLevel();

    static void Context(const ACE_TCHAR *szName);

    static const ACE_TCHAR *Context();

    static void SourceObject(const ACE_TCHAR *soName);

    static const ACE_TCHAR * SourceObject();

    static void audience(const ACE_TCHAR *aud);

    static const ACE_TCHAR * audience();

    static void array(const ACE_TCHAR *aud);

    static const ACE_TCHAR * array();

    static void antenna(const ACE_TCHAR *aud);

    static const ACE_TCHAR * antenna();

    static void host(const ACE_TCHAR *aud);

    static const ACE_TCHAR * host();

    static void AddData(const ACE_TCHAR *szName, const ACE_TCHAR *szFormat, ...);

  public:

    LoggingProxy(const unsigned long cacheSize,
                 const unsigned long minCachePriority,
                 const unsigned long maxCachePriority,
                 Logging::AcsLogService_ptr centralizedLogger = Logging::AcsLogService::_nil(),
                 CosNaming::NamingContext_ptr namingContext = CosNaming::NamingContext::_nil(),
                 const unsigned int autoFlushTimeoutSec = 5);

    ~LoggingProxy();

    void setCentralizedLogger(Logging::AcsLogService_ptr centralizedLogger);

    void setNamingContext(CosNaming::NamingContext_ptr namingContext)
        {
            m_namingContext = CosNaming::NamingContext::_duplicate(namingContext);
        }

    void flush();

    void setStdio(int stdio){ m_envStdioPriority = stdio; }

    //static ACE_TCHAR* m_LogEntryTypeName[];
    //static ACSLoggingLog::LogType m_LogBinEntryTypeName[];

    static void init(LoggingProxy *loggingProxy);

    static void done();
    static std::string BinToXml(ACSLoggingLog::LogBinaryRecord* record);

    static unsigned long getPriority(ACE_Log_Record &log_record);

    void logXML(const ACE_TCHAR *xml, bool cache=true);

    static bool isInit()
        {
            return initialized;
        }

    static bool isInitThread();

    int getCacheLogCount() const { if(!m_logBin) return m_cache.size(); else return m_bin_cache.size();}

  protected:
         char *oldLog;

  private:

    static void formatISO8601inUTC(const ACE_Time_Value &timestamp, ACE_TCHAR str[]);

    void failedToSend();

    void successfullySent();

    bool reconnectToLogger();

    void sendCache();

    void sendCacheInternal();

    bool sendRecord(CORBA::Any &record);
    
    bool sendRecord(const Logging::XmlLogRecordSeq &reclist);

    void sendXmlLogs(ACE_Log_Record &log_record,  const ACE_TCHAR * timestamp, const ACE_TCHAR * entryType);
    void sendBinLogs(ACE_Log_Record &log_record,  const ACE_TCHAR * timestamp, const ACE_TCHAR * entryType);

    unsigned long m_cacheSize;

    unsigned long m_minCachePriority;

    unsigned long m_maxCachePriority;

    unsigned int m_autoFlushTimeoutSec;

    Logging::AcsLogService_var m_logger;
    bool m_noLogger;

    CosNaming::NamingContext_var m_namingContext;

    int m_failureCount;

    static int m_failureLimit;

    ACE_Time_Value m_disconnectionTime;

    static int m_minReconnectionTime;

    typedef std::deque<ACE_CString> LogDeque;
    LogDeque m_cache;


    typedef std::deque<ACSLoggingLog::LogBinaryRecord *> LogBinDeque;
    //typedef std::deque<ACSLoggingLog::LogBinaryRecord > LogBinDeque;
    LogBinDeque m_bin_cache;

   // ACSLoggingLog::LogBinaryRecord * m_binaryRecord;

    bool m_cacheDisabled;

    static char /*ACE_CString*/ m_process[256];

    ACE_Recursive_Thread_Mutex m_mutex;

    bool m_logBin;

    static ACE_TSS<LoggingTSSStorage> * tss;
    static int instances;

    ACE_CString m_filename;

    bool m_alreadyInformed;

    int m_envStdioPriority;
    int m_envCentralizePriority;

    ACE_CString m_syslog;

    static bool initialized;

    static ACE_CString sourceObject_m;

    static unsigned int setClrCount_m;

  ACE_SYNCH_MUTEX m_doWorkMutex;

  ACE_SYNCH_CONDITION m_doWorkCond;

  volatile bool m_sendingPending;

  virtual int svc();

  static void* worker(void*);

  volatile bool m_threadCreated;
  //ACE_Barrier m_threadStart;
  ACE_Barrier m_threadShutdown;
  volatile bool m_shutdown;
};

#endif