clLogApi.h

Go to the documentation of this file.

/*
 * Copyright (C) 2002-2012 OpenClovis Solutions Inc.  All Rights Reserved.
 *
 * This file is available  under  a  commercial  license  from  the
 * copyright  holder or the GNU General Public License Version 2.0.
 * 
 * The source code for  this program is not published  or otherwise 
 * divested of  its trade secrets, irrespective  of  what  has been 
 * deposited with the U.S. Copyright office.
 * 
 * This program 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 
 * General Public License for more details.
 * 
 * For more  information, see  the file  COPYING provided with this
 * material.
 */

#ifndef _CL_LOG_API_H_
#define _CL_LOG_API_H_

#ifdef __cplusplus
extern "C" {
#endif

#include <sys/types.h> /* For getpid() */
#include <unistd.h>

#include <string.h>
#include <stdio.h>
#include <stdarg.h>
#include <clTimerApi.h>
#include <clCommon.h>
#include <clDbg.h>
#include <clLogUtilApi.h>

/*********************************
    Data Types
*********************************/ 
 
typedef ClHandleT  ClLogHandleT;

typedef ClHandleT  ClLogStreamHandleT;

typedef ClHandleT  ClLogFileHandleT;

#define CL_LOG_STREAM_NAME_MAX_LENGTH  128

#define CL_LOG_SLINE_MSG_LEN  256


typedef enum
{
    CL_LOG_STREAM_GLOBAL = 0,
    CL_LOG_STREAM_LOCAL  = 1
}ClLogStreamScopeT;

typedef enum
{
  CL_LOG_FILE_FULL_ACTION_ROTATE = 0,
  CL_LOG_FILE_FULL_ACTION_WRAP   = 1,
  CL_LOG_FILE_FULL_ACTION_HALT   = 2
} ClLogFileFullActionT;

typedef struct
{
    ClCharT               *fileName;
    ClCharT               *fileLocation;
    ClUint32T             fileUnitSize;
    ClUint32T             recordSize;
    ClBoolT               haProperty;
    ClLogFileFullActionT  fileFullAction;
    ClUint32T             maxFilesRotated;
    ClUint32T             flushFreq;
    ClTimeT               flushInterval;
    ClWaterMarkT          waterMark;

    /*
     * Syslog enabler for the stream.
     */
    ClBoolT              syslog;
} ClLogStreamAttributesT;

#define CL_LOG_STREAM_CREATE  0x1

typedef ClUint8T  ClLogStreamOpenFlagsT;

typedef struct
{
    ClNameT                 streamName;
    ClLogStreamScopeT       streamScope;
    ClNameT                 streamScopeNode;
    ClUint16T               streamId;
    ClLogStreamAttributesT  streamAttr;
} ClLogStreamInfoT;

typedef struct 
{
    ClNameT           streamName;
    ClLogStreamScopeT streamScope;
    ClNameT           nodeName;
    ClUint16T         streamId;
} ClLogStreamMapT;

#define CL_LOG_HANDLER_WILL_ACK  0x1

typedef ClUint8T  ClLogStreamHandlerFlagsT;

typedef enum
  {
    CL_LOG_SEV_EMERGENCY = 0x1,
    CL_LOG_SEV_ALERT,
    CL_LOG_SEV_CRITICAL,
    CL_LOG_SEV_ERROR,
    CL_LOG_SEV_WARNING,
    CL_LOG_SEV_NOTICE,
    CL_LOG_SEV_INFO,
    CL_LOG_SEV_DEBUG,
    CL_LOG_SEV_DEBUG1   =      CL_LOG_SEV_DEBUG,
    CL_LOG_SEV_DEBUG2,
    CL_LOG_SEV_DEBUG3,
    CL_LOG_SEV_DEBUG4,
    CL_LOG_SEV_DEBUG5,
    CL_LOG_SEV_TRACE  =    CL_LOG_SEV_DEBUG5,
    CL_LOG_SEV_DEBUG6,
    CL_LOG_SEV_DEBUG7,
    CL_LOG_SEV_DEBUG8,
    CL_LOG_SEV_DEBUG9,
  CL_LOG_SEV_MAX    =    CL_LOG_SEV_DEBUG9
  } ClLogSeverityT;

#if 0

#define CL_LOG_SEV_EMERGENCY  0x1

#define CL_LOG_SEV_ALERT      0x2

#define CL_LOG_SEV_CRITICAL   0x3

#define CL_LOG_SEV_ERROR      0x4

#define CL_LOG_SEV_WARNING    0x5

#define CL_LOG_SEV_NOTICE     0x6

#define CL_LOG_SEV_INFO       0x7

#define CL_LOG_SEV_DEBUG      0x8

#define CL_LOG_SEV_TRACE      CL_LOG_TRACE

#define CL_LOG_SEV_MAX        CL_LOG_DEBUG9
#endif

typedef ClUint16T  ClLogSeverityFilterT;

#define CL_LOG_FILTER_ASSIGN        0x1

#define CL_LOG_FILTER_MERGE_ADD     0x2

#define CL_LOG_FILTER_MERGE_DELETE  0x3

typedef ClUint8T  ClLogFilterFlagsT;


typedef struct
{
    ClLogSeverityFilterT  severityFilter;
    ClUint16T             msgIdSetLength;
    ClUint8T              *pMsgIdSet;
    ClUint16T             compIdSetLength;
    ClUint8T              *pCompIdSet;
} ClLogFilterT;

typedef void (*ClLogStreamOpenCallbackT)(
          CL_IN  ClInvocationT       invocation,
          CL_IN  ClLogStreamHandleT  hStream,
          CL_IN  ClRcT               rc);

typedef void (*ClLogFilterSetCallbackT)(
              CL_IN  ClLogStreamHandleT  hStream,
              CL_IN  ClLogFilterT        filter);

typedef void (*ClLogRecordDeliveryCallbackT)(
              CL_IN  ClLogStreamHandleT  hStream,
              CL_IN  ClUint64T           seqNum,
              CL_IN  ClUint32T           numRecords,
              CL_IN  ClPtrT              pRecords);

typedef struct
{
    ClLogStreamOpenCallbackT      clLogStreamOpenCb;
    ClLogFilterSetCallbackT       clLogFilterSetCb;
    ClLogRecordDeliveryCallbackT  clLogRecordDeliveryCb;
#if 0
    ClLogWriteCallbackT           clLogWriteCallback;
#endif
} ClLogCallbacksT;


#define CL_LOG_MSGID_BUFFER      0

#define CL_LOG_MSGID_PRINTF_FMT  1

#define CL_LOG_TAG_TERMINATE       0

#define CL_LOG_TAG_BASIC_SIGNED    0x1

#define CL_LOG_TAG_BASIC_UNSIGNED  0x2

#define CL_LOG_TAG_STRING    0x3

#define CL_LOG_TLV_UINT8(var)                              \
    CL_LOG_TAG_BASIC_UNSIGNED, sizeof( var ), &(var)

#define CL_LOG_TLV_INT8(var)                               \
    CL_LOG_TAG_BASIC_SIGNED, sizeof( var ), &(var)

#define CL_LOG_TLV_UINT16(var)                             \
    CL_LOG_TAG_BASIC_UNSIGNED, sizeof( var ), &(var)

#define CL_LOG_TLV_INT16(var)                              \
    CL_LOG_TAG_BASIC_SIGNED, sizeof( var ), &(var)

#define CL_LOG_TLV_UINT32(var)                             \
    CL_LOG_TAG_BASIC_UNSIGNED, sizeof( var ), &(var)

#define CL_LOG_TLV_INT32(var)                              \
    CL_LOG_TAG_BASIC_SIGNED, sizeof( var ), &(var)

#define CL_LOG_TLV_UINT64(var)                             \
    CL_LOG_TAG_BASIC_UNSIGNED, sizeof( var ), &(var)

#define CL_LOG_TLV_INT64(var)                              \
    CL_LOG_TAG_BASIC_SIGNED, sizeof( var ), &(var)

#define CL_LOG_TLV_STRING(var)                              \
    CL_LOG_TAG_STRING, (strlen( var ) + 1), (var)


extern ClRcT
clLogInitialize(CL_OUT   ClLogHandleT           *phLog,
                CL_IN    const ClLogCallbacksT  *pLogCallbacks,
                CL_INOUT ClVersionT             *pVersion);

extern ClRcT clLogFinalize(CL_IN ClLogHandleT  hLog);

extern ClRcT
clLogStreamOpen(CL_IN  ClLogHandleT            hLog,
                CL_IN  ClNameT                 streamName,
                CL_IN  ClLogStreamScopeT       streamScope,
                CL_IN  ClLogStreamAttributesT  *pStreamAttr,
                CL_IN  ClLogStreamOpenFlagsT   streamOpenFlags,
                CL_IN  ClTimeT                 timeout,
                CL_OUT ClLogStreamHandleT      *phStream);
extern ClRcT
clLogStreamClose(CL_IN  ClLogStreamHandleT hStream);

extern ClRcT
clLogWriteAsync(ClLogStreamHandleT   hStream,
                ClLogSeverityT       severity,
                ClUint16T            serviceId,
                ClUint16T            msgId,
                ...);

extern ClRcT
clLogWriteAsyncWithHeader(ClLogStreamHandleT   hStream,
                          ClLogSeverityT       severity,
                          ClUint16T            serviceId,
                          ClUint16T            msgId,
                          ...);

extern ClRcT
clLogWriteAsyncWithContextHeader(ClLogStreamHandleT   hStream,
                                 ClLogSeverityT       severity,
                                 const ClCharT        *pArea,
                                 const ClCharT        *pContext,
                                 ClUint16T            serviceId,
                                 ClUint16T            msgId,
                                 ...);

extern ClRcT
clLogFilterSet(CL_IN ClLogStreamHandleT  hStream,
               CL_IN ClLogFilterFlagsT   filterFlags,
               CL_IN ClLogFilterT        filter);

extern ClRcT
clLogHandlerRegister(CL_IN   ClLogHandleT              hLog,
                     CL_IN   ClNameT                   streamName, 
                     CL_IN   ClLogStreamScopeT         streamScope,
                     CL_IN   ClNameT                   nodeName,   
                     CL_IN   ClLogStreamHandlerFlagsT  handlerFlags,
                     CL_OUT  ClLogHandleT              *phStream);
 extern ClRcT
 clLogHandlerDeregister(CL_IN ClLogStreamHandleT  hStream);

 extern ClRcT
 clLogHandlerRecordAck(CL_IN ClLogStreamHandleT  hStream,
                       CL_IN ClUint64T           sequenceNumber,
                       CL_IN ClUint32T           numRecords);

extern ClRcT
clLogFileOpen(CL_IN ClLogHandleT      hLog,
              CL_IN ClCharT           *fileName,
              CL_IN ClCharT           *fileLocation,
              CL_IN ClBoolT           isDelete, 
              CL_IN ClLogFileHandleT  *phFile);

extern ClRcT
clLogFileClose(CL_IN ClLogFileHandleT  hFileHdlr);

extern ClRcT
clLogFileMetaDataGet(CL_IN  ClLogFileHandleT        hFileHdlr,
                     CL_OUT ClLogStreamAttributesT  *pStreamAttr,
                     CL_OUT ClUint32T               *pNumStreams,
                     CL_OUT ClLogStreamMapT         **ppLogStreams);

extern ClRcT
clLogFileRecordsGet(CL_IN  ClLogFileHandleT  hFileHdlr,
                    CL_OUT ClTimeT           *pStarTime,
                    CL_OUT ClTimeT           *pEndTime, 
                    CL_OUT ClUint32T         *pNumRecords,
                    CL_OUT ClPtrT            *pLogRecords);
extern ClRcT
clLogStreamListGet(CL_IN  ClLogHandleT      hLog,
                   CL_OUT ClUint32T         *pNumStreams,
                   CL_OUT ClLogStreamInfoT  **ppLogStreams);

 #define clLogWrite(streamHdl, severity, libName, ...)\
 do\
 {\
    clLog(severity, libName, CL_LOG_CONTEXT_UNSPECIFIED, __VA_ARGS__);\
 } while(0)

ClRcT
clLogWriteDeferred(ClHandleT      handle,
                   ClLogSeverityT severity,
                   ClUint16T      servicId,
                   ClUint16T      msgId,
                   ClCharT        *pFmtStr,
                   ...) CL_PRINTF_FORMAT(5, 6);

ClRcT
clLogWriteDeferredForce(ClHandleT      handle,
                        ClLogSeverityT severity,
                        ClUint16T      servicId,
                        ClUint16T      msgId,
                        ClCharT        *pFmtStr,
                        ...) CL_PRINTF_FORMAT(5, 6);

extern ClRcT
clLogMsgWrite(ClHandleT       streamHdl,
              ClLogSeverityT  severity,
              ClUint16T       serviceId,
              const ClCharT         *pArea,
              const ClCharT         *pContext,
              const ClCharT         *pFileName,
              ClUint32T       lineNum,
              const ClCharT   *pFmtStr,
              ...) CL_PRINTF_FORMAT(8, 9);

extern ClRcT
clLogMsgWriteDeferred(ClHandleT       streamHdl,
                      ClLogSeverityT  severity,
                      ClUint16T       serviceId,
                      const ClCharT         *pArea,
                      const ClCharT         *pContext,
                      const ClCharT         *pFileName,
                      ClUint32T       lineNum,
                      const ClCharT   *pFmtStr,
                      ...) CL_PRINTF_FORMAT(8, 9);

extern ClRcT
clLogMsgWriteConsole(ClHandleT       streamHdl,
                     ClLogSeverityT  severity,
                     ClUint16T       serviceId,
                     const ClCharT         *pArea,
                     const ClCharT         *pContext,
                     const ClCharT         *pFileName,
                     ClUint32T       lineNum,
                     const ClCharT   *pFmtStr,
                     ...) CL_PRINTF_FORMAT(8, 9);

ClRcT clLogSeverityFilterToValueGet(ClLogSeverityFilterT filter, ClLogSeverityT* pSeverity);
ClRcT clLogSeverityValueToFilterGet(ClLogSeverityT severity, ClLogSeverityFilterT* pFilter);

ClRcT clLogStreamFilterSet(ClNameT                  *pStreamName, 
                                ClLogStreamScopeT   streamScope,
                                ClNameT             *pStreamScopeNode,
                                ClLogFilterFlagsT   filterFlags,
                                ClLogFilterT        filter);

ClRcT
clLogStreamFilterGet(ClNameT                *pStreamName,
                        ClLogStreamScopeT   streamScope,
                        ClNameT             *pStreamScopeNode,
                        ClLogFilterT        *pFilter);

ClLogSeverityT
clLogSeverityGet(const ClCharT  *pSevName);

#include <ipi/clLogIpiWrap.h> 
#ifdef __cplusplus
}
#endif

#endif /*_CL_LOG_API_H_*/