Skip to content

M
mariadb
Commit 3f255881 authored by unknown's avatar unknown
Browse files
Options

WL#2299, structured log events

parent 0eb1a810
Show whitespace changes
Inline Side-by-side
Showing with 1966 additions and 1395 deletions
ndb/docs/doxygen/Doxyfile.mgmapi
View file @ 3f255881
...@@ -688,7 +688,8 @@ INCLUDE_FILE_PATTERNS = ...@@ -688,7 +688,8 @@ INCLUDE_FILE_PATTERNS =
# or name=definition (no spaces). If the definition and the = are # or name=definition (no spaces). If the definition and the = are
# omitted =1 is assumed. # omitted =1 is assumed.
PREDEFINED = DOXYGEN_SHOULD_SKIP_DEPRECATED \ PREDEFINED = DOXYGEN_FIX \
DOXYGEN_SHOULD_SKIP_DEPRECATED \
DOXYGEN_SHOULD_SKIP_INTERNAL \ DOXYGEN_SHOULD_SKIP_INTERNAL \
protected=private protected=private
......
ndb/examples/mgmapi_logevent_example/mgmapi_logevent.cpp 0 → 100644
View file @ 3f255881
/* Copyright (C) 2003 MySQL AB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
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.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
#include <mysql.h>
#include <ndbapi/NdbApi.hpp>
#include <mgmapi.h>
#include <stdio.h>
/*
* export LD_LIBRARY_PATH=../../../libmysql_r/.libs:../../../ndb/src/.libs
*/
#define MGMERROR(h) \
{ \
fprintf(stderr, "code: %d msg: %s\n", \
ndb_mgm_get_latest_error(h), \
ndb_mgm_get_latest_error_msg(h)); \
exit(-1); \
}
#define LOGEVENTERROR(h) \
{ \
fprintf(stderr, "code: %d msg: %s\n", \
ndb_logevent_get_latest_error(h), \
ndb_logevent_get_latest_error_msg(h)); \
exit(-1); \
}
int main()
{
NdbMgmHandle h;
NdbLogEventHandle l;
int filter[] = { 15, NDB_MGM_EVENT_CATEGORY_BACKUP, 0 };
struct ndb_logevent event;
ndb_init();
h= ndb_mgm_create_handle();
if ( h == 0)
{
printf("Unable to create handle\n");
exit(-1);
}
if (ndb_mgm_connect(h,0,0,0)) MGMERROR(h);
l= ndb_mgm_create_logevent_handle(h, filter);
if ( l == 0 ) MGMERROR(h);
while (1)
{
int timeout= 5000;
int r= ndb_logevent_get_next(l,&event,timeout);
if (r == 0)
printf("No event within %d milliseconds\n", timeout);
else if (r < 0)
LOGEVENTERROR(l)
else
{
printf("Event %d from node ID %d\n",
event.type,
event.source_nodeid);
printf("Category %d, severity %d, level %d\n",
event.category,
event.severity,
event.level);
switch (event.type) {
case NDB_LE_BackupStarted:
printf("BackupStartded\n");
printf("Starting node ID: %d\n", event.BackupStarted.starting_node);
printf("Backup ID: %d\n", event.BackupStarted.backup_id);
break;
case NDB_LE_BackupCompleted:
printf("BackupCompleted\n");
printf("Backup ID: %d\n", event.BackupStarted.backup_id);
break;
case NDB_LE_BackupAborted:
break;
case NDB_LE_BackupFailedToStart:
break;
default:
printf("Unexpected event\n");
break;
}
}
}
ndb_mgm_destroy_logevent_handle(&l);
ndb_mgm_destroy_handle(&h);
ndb_end(0);
return 0;
}
ndb/include/debugger/EventLogger.hpp
View file @ 3f255881
...@@ -17,12 +17,12 @@ ...@@ -17,12 +17,12 @@
#ifndef EVENTLOGGER_H #ifndef EVENTLOGGER_H
#define EVENTLOGGER_H #define EVENTLOGGER_H
#include <Logger.hpp> #include <logger/Logger.hpp>
#include <FileLogHandler.hpp> #include <logger/FileLogHandler.hpp>
#include <GrepError.hpp> #include "GrepError.hpp"
#include <kernel_types.h> #include <kernel/kernel_types.h>
#include <kernel/LogLevel.hpp> #include <kernel/LogLevel.hpp>
#include <signaldata/EventReport.hpp> #include <kernel/signaldata/EventReport.hpp>
class EventLoggerBase { class EventLoggerBase {
public: public:
...@@ -39,11 +39,14 @@ public: ...@@ -39,11 +39,14 @@ public:
* threshold - is in range [0-15] * threshold - is in range [0-15]
* severity - DEBUG to ALERT (Type of log message) * severity - DEBUG to ALERT (Type of log message)
*/ */
typedef void (* EventTextFunction)(char *,size_t,const Uint32*);
struct EventRepLogLevelMatrix { struct EventRepLogLevelMatrix {
Ndb_logevent_type eventType; Ndb_logevent_type eventType;
LogLevel::EventCategory eventCategory; LogLevel::EventCategory eventCategory;
Uint32 threshold; Uint32 threshold;
Logger::LoggerLevel severity; Logger::LoggerLevel severity;
EventTextFunction textF;
}; };
static const EventRepLogLevelMatrix matrix[]; static const EventRepLogLevelMatrix matrix[];
...@@ -51,7 +54,8 @@ public: ...@@ -51,7 +54,8 @@ public:
static int event_lookup(int eventType, static int event_lookup(int eventType,
LogLevel::EventCategory &cat, LogLevel::EventCategory &cat,
Uint32 &threshold, Uint32 &threshold,
Logger::LoggerLevel &severity); Logger::LoggerLevel &severity,
EventTextFunction &textF);
}; };
/** /**
...@@ -131,16 +135,17 @@ public: ...@@ -131,16 +135,17 @@ public:
*/ */
virtual void log(int, const Uint32*, NodeId = 0,const class LogLevel * = 0); virtual void log(int, const Uint32*, NodeId = 0,const class LogLevel * = 0);
/** /**
* Returns the event text for the specified event report type. * Returns the event text for the specified event report type.
* *
* @param type the event type. * @param textF print function for the event
* @param theData the event data. * @param theData the event data.
* @param nodeId a node id. * @param nodeId a node id.
* @return the event report text. * @return the event report text.
*/ */
static const char* getText(char * dst, size_t dst_len, static const char* getText(char * dst, size_t dst_len,
int type, EventTextFunction textF,
const Uint32* theData, NodeId nodeId = 0); const Uint32* theData, NodeId nodeId = 0);
/** /**
......
ndb/include/kernel/LogLevel.hpp
View file @ 3f255881
...@@ -147,7 +147,7 @@ LogLevel::set_max(const LogLevel & org){ ...@@ -147,7 +147,7 @@ LogLevel::set_max(const LogLevel & org){
return * this; return * this;
} }
#include <signaldata/EventSubscribeReq.hpp> #include "signaldata/EventSubscribeReq.hpp"
inline inline
LogLevel& LogLevel&
......
ndb/include/kernel/signaldata/SignalData.hpp
View file @ 3f255881
...@@ -18,8 +18,8 @@ ...@@ -18,8 +18,8 @@
#define SIGNAL_DATA_H #define SIGNAL_DATA_H
#include <ndb_global.h> #include <ndb_global.h>
#include <ndb_limits.h> #include <kernel/ndb_limits.h>
#include <kernel_types.h> #include <kernel/kernel_types.h>
#include <BaseString.hpp> #include <BaseString.hpp>
#define ASSERT_BOOL(flag, message) assert(flag<=1) #define ASSERT_BOOL(flag, message) assert(flag<=1)
......
ndb/include/mgmapi/mgmapi.h
View file @ 3f255881
...@@ -86,6 +86,53 @@ ...@@ -86,6 +86,53 @@
* int filter[] = { 15, NDB_MGM_EVENT_CATEGORY_BACKUP, 0 }; * int filter[] = { 15, NDB_MGM_EVENT_CATEGORY_BACKUP, 0 };
* int fd = ndb_mgm_listen_event(handle, filter); * int fd = ndb_mgm_listen_event(handle, filter);
* @endcode * @endcode
*
*
* @section secSLogEvents Structured Log Events
*
* The following steps are involved:
* - Create a NdbEventLogHandle using ndb_mgm_create_logevent_handle()
* - Wait and store log events using ndb_logevent_get_next()
* - The log event data is available in the struct ndb_logevent. The
* data which is specific to a particular event is stored in a union
* between structs so use ndb_logevent::type to decide which struct
* is valid.
*
* Sample code for listening to Backup related events. The availaable log
* events are listed in @ref ndb_logevent.h
*
* @code
* int filter[] = { 15, NDB_MGM_EVENT_CATEGORY_BACKUP, 0 };
* NdbEventLogHandle le_handle= ndb_mgm_create_logevent_handle(handle, filter);
* struct ndb_logevent le;
* int r= ndb_logevent_get_next(le_handle,&le,0);
* if (r < 0) error
* else if (r == 0) no event
*
* switch (le.type)
* {
* case NDB_LE_BackupStarted:
* ... le.BackupStarted.starting_node;
* ... le.BackupStarted.backup_id;
* break;
* case NDB_LE_BackupFailedToStart:
* ... le.BackupFailedToStart.error;
* break;
* case NDB_LE_BackupCompleted:
* ... le.BackupCompleted.stop_gci;
* break;
* case NDB_LE_BackupAborted:
* ... le.BackupStarted.backup_id;
* break;
* default:
* break;
* }
* @endcode
*/
/*
* @page ndb_logevent.h ndb_logevent.h
* @include ndb_logevent.h
*/ */
/** @addtogroup MGM_C_API /** @addtogroup MGM_C_API
...@@ -93,6 +140,7 @@ ...@@ -93,6 +140,7 @@
*/ */
#include <ndb_types.h> #include <ndb_types.h>
#include "ndb_logevent.h"
#include "mgmapi_config_parameters.h" #include "mgmapi_config_parameters.h"
#ifdef __cplusplus #ifdef __cplusplus
...@@ -348,97 +396,6 @@ extern "C" { ...@@ -348,97 +396,6 @@ extern "C" {
}; };
#endif #endif
/**
* Log event severities (used to filter the cluster log,
* ndb_mgm_set_clusterlog_severity_filter(), and filter listening to events
* ndb_mgm_listen_event())
*/
enum ndb_mgm_event_severity {
NDB_MGM_ILLEGAL_EVENT_SEVERITY = -1,
/* Must be a nonnegative integer (used for array indexing) */
/** Cluster log on */
NDB_MGM_EVENT_SEVERITY_ON = 0,
/** Used in NDB Cluster developement */
NDB_MGM_EVENT_SEVERITY_DEBUG = 1,
/** Informational messages*/
NDB_MGM_EVENT_SEVERITY_INFO = 2,
/** Conditions that are not error condition, but might require handling.
*/
NDB_MGM_EVENT_SEVERITY_WARNING = 3,
/** Conditions that, while not fatal, should be corrected. */
NDB_MGM_EVENT_SEVERITY_ERROR = 4,
/** Critical conditions, like device errors or out of resources */
NDB_MGM_EVENT_SEVERITY_CRITICAL = 5,
/** A condition that should be corrected immediately,
* such as a corrupted system
*/
NDB_MGM_EVENT_SEVERITY_ALERT = 6,
/* must be next number, works as bound in loop */
/** All severities */
NDB_MGM_EVENT_SEVERITY_ALL = 7
};
/**
* Log event categories, used to set filter level on the log events using
* ndb_mgm_set_clusterlog_loglevel() and ndb_mgm_listen_event()
*/
enum ndb_mgm_event_category {
/**
* Invalid log event category
*/
NDB_MGM_ILLEGAL_EVENT_CATEGORY = -1,
/**
* Log events during all kinds of startups
*/
NDB_MGM_EVENT_CATEGORY_STARTUP = CFG_LOGLEVEL_STARTUP,
/**
* Log events during shutdown
*/
NDB_MGM_EVENT_CATEGORY_SHUTDOWN = CFG_LOGLEVEL_SHUTDOWN,
/**
* Statistics log events
*/
NDB_MGM_EVENT_CATEGORY_STATISTIC = CFG_LOGLEVEL_STATISTICS,
/**
* Log events related to checkpoints
*/
NDB_MGM_EVENT_CATEGORY_CHECKPOINT = CFG_LOGLEVEL_CHECKPOINT,
/**
* Log events during node restart
*/
NDB_MGM_EVENT_CATEGORY_NODE_RESTART = CFG_LOGLEVEL_NODERESTART,
/**
* Log events related to connections between cluster nodes
*/
NDB_MGM_EVENT_CATEGORY_CONNECTION = CFG_LOGLEVEL_CONNECTION,
/**
* Backup related log events
*/
NDB_MGM_EVENT_CATEGORY_BACKUP = CFG_LOGLEVEL_BACKUP,
/**
* Congestion related log events
*/
NDB_MGM_EVENT_CATEGORY_CONGESTION = CFG_LOGLEVEL_CONGESTION,
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
/**
* Loglevel debug
*/
NDB_MGM_EVENT_CATEGORY_DEBUG = CFG_LOGLEVEL_DEBUG,
#endif
/**
* Uncategorized log events (severity info)
*/
NDB_MGM_EVENT_CATEGORY_INFO = CFG_LOGLEVEL_INFO,
/**
* Uncategorized log events (severity warning or higher)
*/
NDB_MGM_EVENT_CATEGORY_ERROR = CFG_LOGLEVEL_ERROR,
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
NDB_MGM_MIN_EVENT_CATEGORY = CFG_MIN_LOGLEVEL,
NDB_MGM_MAX_EVENT_CATEGORY = CFG_MAX_LOGLEVEL
#endif
};
/***************************************************************************/ /***************************************************************************/
/** /**
* @name Functions: Error Handling * @name Functions: Error Handling
...@@ -871,6 +828,64 @@ extern "C" { ...@@ -871,6 +828,64 @@ extern "C" {
struct ndb_mgm_reply* reply); struct ndb_mgm_reply* reply);
#endif #endif
/**
* The NdbLogEventHandle
*/
typedef struct ndb_logevent_handle * NdbLogEventHandle;
/**
* Listen to log events.
*
* @param handle NDB management handle.
* @param filter pairs of { level, ndb_mgm_event_category } that will be
* pushed to fd, level=0 ends list.
*
* @return NdbLogEventHandle
*/
NdbLogEventHandle ndb_mgm_create_logevent_handle(NdbMgmHandle,
const int filter[]);
void ndb_mgm_destroy_logevent_handle(NdbLogEventHandle*);
/**
* Retrieve filedescriptor from NdbLogEventHandle. May be used in
* e.g. an application select() statement.
*
* @note Do not attemt to read from it, it will corrupt the parsing.
*
* @return filedescriptor, -1 on failure.
*/
int ndb_logevent_get_fd(const NdbLogEventHandle);
/**
* Attempt to retrieve next log event and will fill in the supplied
* struct dst
*
* @param dst Pointer to struct to fill in event information
* @param timeout_in_milliseconds Timeout for waiting for event
*
* @return >0 if event exists, 0 no event (timed out), or -1 on error.
*
* @note Return value <=0 will leave dst untouched
*/
int ndb_logevent_get_next(const NdbLogEventHandle,
struct ndb_logevent *dst,
unsigned timeout_in_milliseconds);
/**
* Retrieve laterst error code
*
* @return error code
*/
int ndb_logevent_get_latest_error(const NdbLogEventHandle);
/**
* Retrieve laterst error message
*
* @return error message
*/
const char *ndb_logevent_get_latest_error_msg(const NdbLogEventHandle);
/** @} *********************************************************************/ /** @} *********************************************************************/
/** /**
* @name Functions: Backup * @name Functions: Backup
......
ndb/include/mgmapi/ndb_logevent.h
View file @ 3f255881
...@@ -17,90 +17,542 @@ ...@@ -17,90 +17,542 @@
#ifndef NDB_LOGEVENT_H #ifndef NDB_LOGEVENT_H
#define NDB_LOGEVENT_H #define NDB_LOGEVENT_H
/** @addtogroup MGM_C_API
* @{
*/
#include "mgmapi_config_parameters.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/**
* Available log events grouped by @ref ndb_mgm_event_category
*/
enum Ndb_logevent_type { enum Ndb_logevent_type {
/* CONNECTION */
NDB_LE_ILLEGAL_TYPE = -1,
/** NDB_MGM_EVENT_CATEGORY_CONNECTION */
NDB_LE_Connected = 0, NDB_LE_Connected = 0,
/** NDB_MGM_EVENT_CATEGORY_CONNECTION */
NDB_LE_Disconnected = 1, NDB_LE_Disconnected = 1,
/** NDB_MGM_EVENT_CATEGORY_CONNECTION */
NDB_LE_CommunicationClosed = 2, NDB_LE_CommunicationClosed = 2,
/** NDB_MGM_EVENT_CATEGORY_CONNECTION */
NDB_LE_CommunicationOpened = 3, NDB_LE_CommunicationOpened = 3,
/** NDB_MGM_EVENT_CATEGORY_CONNECTION */
NDB_LE_ConnectedApiVersion = 51, NDB_LE_ConnectedApiVersion = 51,
/* CHECKPOINT */
/** NDB_MGM_EVENT_CATEGORY_CHECKPOINT */
NDB_LE_GlobalCheckpointStarted = 4, NDB_LE_GlobalCheckpointStarted = 4,
/** NDB_MGM_EVENT_CATEGORY_CHECKPOINT */
NDB_LE_GlobalCheckpointCompleted = 5, NDB_LE_GlobalCheckpointCompleted = 5,
/** NDB_MGM_EVENT_CATEGORY_CHECKPOINT */
NDB_LE_LocalCheckpointStarted = 6, NDB_LE_LocalCheckpointStarted = 6,
/** NDB_MGM_EVENT_CATEGORY_CHECKPOINT */
NDB_LE_LocalCheckpointCompleted = 7, NDB_LE_LocalCheckpointCompleted = 7,
/** NDB_MGM_EVENT_CATEGORY_CHECKPOINT */
NDB_LE_LCPStoppedInCalcKeepGci = 8, NDB_LE_LCPStoppedInCalcKeepGci = 8,
/** NDB_MGM_EVENT_CATEGORY_CHECKPOINT */
NDB_LE_LCPFragmentCompleted = 9, NDB_LE_LCPFragmentCompleted = 9,
/* STARTUP */
/** NDB_MGM_EVENT_CATEGORY_STARTUP */
NDB_LE_NDBStartStarted = 10, NDB_LE_NDBStartStarted = 10,
/** NDB_MGM_EVENT_CATEGORY_STARTUP */
NDB_LE_NDBStartCompleted = 11, NDB_LE_NDBStartCompleted = 11,
/** NDB_MGM_EVENT_CATEGORY_STARTUP */
NDB_LE_STTORRYRecieved = 12, NDB_LE_STTORRYRecieved = 12,
/** NDB_MGM_EVENT_CATEGORY_STARTUP */
NDB_LE_StartPhaseCompleted = 13, NDB_LE_StartPhaseCompleted = 13,
/** NDB_MGM_EVENT_CATEGORY_STARTUP */
NDB_LE_CM_REGCONF = 14, NDB_LE_CM_REGCONF = 14,
/** NDB_MGM_EVENT_CATEGORY_STARTUP */
NDB_LE_CM_REGREF = 15, NDB_LE_CM_REGREF = 15,
/** NDB_MGM_EVENT_CATEGORY_STARTUP */
NDB_LE_FIND_NEIGHBOURS = 16, NDB_LE_FIND_NEIGHBOURS = 16,
/** NDB_MGM_EVENT_CATEGORY_STARTUP */
NDB_LE_NDBStopStarted = 17, NDB_LE_NDBStopStarted = 17,
/** NDB_MGM_EVENT_CATEGORY_STARTUP */
NDB_LE_NDBStopAborted = 18, NDB_LE_NDBStopAborted = 18,
/** NDB_MGM_EVENT_CATEGORY_STARTUP */
NDB_LE_StartREDOLog = 19, NDB_LE_StartREDOLog = 19,
/** NDB_MGM_EVENT_CATEGORY_STARTUP */
NDB_LE_StartLog = 20, NDB_LE_StartLog = 20,
/** NDB_MGM_EVENT_CATEGORY_STARTUP */
NDB_LE_UNDORecordsExecuted = 21, NDB_LE_UNDORecordsExecuted = 21,
/* NODERESTART */ /** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
NDB_LE_NR_CopyDict = 22, NDB_LE_NR_CopyDict = 22,
/** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
NDB_LE_NR_CopyDistr = 23, NDB_LE_NR_CopyDistr = 23,
/** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
NDB_LE_NR_CopyFragsStarted = 24, NDB_LE_NR_CopyFragsStarted = 24,
/** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
NDB_LE_NR_CopyFragDone = 25, NDB_LE_NR_CopyFragDone = 25,
/** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
NDB_LE_NR_CopyFragsCompleted = 26, NDB_LE_NR_CopyFragsCompleted = 26,
/* NODEFAIL */ /* NODEFAIL */
/** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
NDB_LE_NodeFailCompleted = 27, NDB_LE_NodeFailCompleted = 27,
/** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
NDB_LE_NODE_FAILREP = 28, NDB_LE_NODE_FAILREP = 28,
/** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
NDB_LE_ArbitState = 29, NDB_LE_ArbitState = 29,
/** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
NDB_LE_ArbitResult = 30, NDB_LE_ArbitResult = 30,
/** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
NDB_LE_GCP_TakeoverStarted = 31, NDB_LE_GCP_TakeoverStarted = 31,
/** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
NDB_LE_GCP_TakeoverCompleted = 32, NDB_LE_GCP_TakeoverCompleted = 32,
/** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
NDB_LE_LCP_TakeoverStarted = 33, NDB_LE_LCP_TakeoverStarted = 33,
/** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
NDB_LE_LCP_TakeoverCompleted = 34, NDB_LE_LCP_TakeoverCompleted = 34,
/* STATISTIC */ /** NDB_MGM_EVENT_CATEGORY_STATISTIC */
NDB_LE_TransReportCounters = 35, NDB_LE_TransReportCounters = 35,
/** NDB_MGM_EVENT_CATEGORY_STATISTIC */
NDB_LE_OperationReportCounters = 36, NDB_LE_OperationReportCounters = 36,
/** NDB_MGM_EVENT_CATEGORY_STATISTIC */
NDB_LE_TableCreated = 37, NDB_LE_TableCreated = 37,
/** NDB_MGM_EVENT_CATEGORY_STATISTIC */
NDB_LE_UndoLogBlocked = 38, NDB_LE_UndoLogBlocked = 38,
/** NDB_MGM_EVENT_CATEGORY_STATISTIC */
NDB_LE_JobStatistic = 39, NDB_LE_JobStatistic = 39,
/** NDB_MGM_EVENT_CATEGORY_STATISTIC */
NDB_LE_SendBytesStatistic = 40, NDB_LE_SendBytesStatistic = 40,
/** NDB_MGM_EVENT_CATEGORY_STATISTIC */
NDB_LE_ReceiveBytesStatistic = 41, NDB_LE_ReceiveBytesStatistic = 41,
/** NDB_MGM_EVENT_CATEGORY_STATISTIC */
NDB_LE_MemoryUsage = 50, NDB_LE_MemoryUsage = 50,
/* ERROR */ /** NDB_MGM_EVENT_CATEGORY_ERROR */
NDB_LE_TransporterError = 42, NDB_LE_TransporterError = 42,
/** NDB_MGM_EVENT_CATEGORY_ERROR */
NDB_LE_TransporterWarning = 43, NDB_LE_TransporterWarning = 43,
/** NDB_MGM_EVENT_CATEGORY_ERROR */
NDB_LE_MissedHeartbeat = 44, NDB_LE_MissedHeartbeat = 44,
/** NDB_MGM_EVENT_CATEGORY_ERROR */
NDB_LE_DeadDueToHeartbeat = 45, NDB_LE_DeadDueToHeartbeat = 45,
/** NDB_MGM_EVENT_CATEGORY_ERROR */
NDB_LE_WarningEvent = 46, NDB_LE_WarningEvent = 46,
/* INFO */ /** NDB_MGM_EVENT_CATEGORY_INFO */
NDB_LE_SentHeartbeat = 47, NDB_LE_SentHeartbeat = 47,
/** NDB_MGM_EVENT_CATEGORY_INFO */
NDB_LE_CreateLogBytes = 48, NDB_LE_CreateLogBytes = 48,
/** NDB_MGM_EVENT_CATEGORY_INFO */
NDB_LE_InfoEvent = 49, NDB_LE_InfoEvent = 49,
/* GREP */ /* GREP */
NDB_LE_GrepSubscriptionInfo = 52, NDB_LE_GrepSubscriptionInfo = 52,
NDB_LE_GrepSubscriptionAlert = 53, NDB_LE_GrepSubscriptionAlert = 53,
/* BACKUP */ /** NDB_MGM_EVENT_CATEGORY_BACKUP */
NDB_LE_BackupStarted = 54, NDB_LE_BackupStarted = 54,
/** NDB_MGM_EVENT_CATEGORY_BACKUP */
NDB_LE_BackupFailedToStart = 55, NDB_LE_BackupFailedToStart = 55,
/** NDB_MGM_EVENT_CATEGORY_BACKUP */
NDB_LE_BackupCompleted = 56, NDB_LE_BackupCompleted = 56,
/** NDB_MGM_EVENT_CATEGORY_BACKUP */
NDB_LE_BackupAborted = 57 NDB_LE_BackupAborted = 57
}; };
/**
* Log event severities (used to filter the cluster log,
* ndb_mgm_set_clusterlog_severity_filter(), and filter listening to events
* ndb_mgm_listen_event())
*/
enum ndb_mgm_event_severity {
NDB_MGM_ILLEGAL_EVENT_SEVERITY = -1,
/* Must be a nonnegative integer (used for array indexing) */
/** Cluster log on */
NDB_MGM_EVENT_SEVERITY_ON = 0,
/** Used in NDB Cluster developement */
NDB_MGM_EVENT_SEVERITY_DEBUG = 1,
/** Informational messages*/
NDB_MGM_EVENT_SEVERITY_INFO = 2,
/** Conditions that are not error condition, but might require handling.
*/
NDB_MGM_EVENT_SEVERITY_WARNING = 3,
/** Conditions that, while not fatal, should be corrected. */
NDB_MGM_EVENT_SEVERITY_ERROR = 4,
/** Critical conditions, like device errors or out of resources */
NDB_MGM_EVENT_SEVERITY_CRITICAL = 5,
/** A condition that should be corrected immediately,
* such as a corrupted system
*/
NDB_MGM_EVENT_SEVERITY_ALERT = 6,
/* must be next number, works as bound in loop */
/** All severities */
NDB_MGM_EVENT_SEVERITY_ALL = 7
};
/**
* Log event categories, used to set filter level on the log events using
* ndb_mgm_set_clusterlog_loglevel() and ndb_mgm_listen_event()
*/
enum ndb_mgm_event_category {
/**
* Invalid log event category
*/
NDB_MGM_ILLEGAL_EVENT_CATEGORY = -1,
/**
* Log events during all kinds of startups
*/
NDB_MGM_EVENT_CATEGORY_STARTUP = CFG_LOGLEVEL_STARTUP,
/**
* Log events during shutdown
*/
NDB_MGM_EVENT_CATEGORY_SHUTDOWN = CFG_LOGLEVEL_SHUTDOWN,
/**
* Statistics log events
*/
NDB_MGM_EVENT_CATEGORY_STATISTIC = CFG_LOGLEVEL_STATISTICS,
/**
* Log events related to checkpoints
*/
NDB_MGM_EVENT_CATEGORY_CHECKPOINT = CFG_LOGLEVEL_CHECKPOINT,
/**
* Log events during node restart
*/
NDB_MGM_EVENT_CATEGORY_NODE_RESTART = CFG_LOGLEVEL_NODERESTART,
/**
* Log events related to connections between cluster nodes
*/
NDB_MGM_EVENT_CATEGORY_CONNECTION = CFG_LOGLEVEL_CONNECTION,
/**
* Backup related log events
*/
NDB_MGM_EVENT_CATEGORY_BACKUP = CFG_LOGLEVEL_BACKUP,
/**
* Congestion related log events
*/
NDB_MGM_EVENT_CATEGORY_CONGESTION = CFG_LOGLEVEL_CONGESTION,
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
/**
* Loglevel debug
*/
NDB_MGM_EVENT_CATEGORY_DEBUG = CFG_LOGLEVEL_DEBUG,
#endif
/**
* Uncategorized log events (severity info)
*/
NDB_MGM_EVENT_CATEGORY_INFO = CFG_LOGLEVEL_INFO,
/**
* Uncategorized log events (severity warning or higher)
*/
NDB_MGM_EVENT_CATEGORY_ERROR = CFG_LOGLEVEL_ERROR,
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
NDB_MGM_MIN_EVENT_CATEGORY = CFG_MIN_LOGLEVEL,
NDB_MGM_MAX_EVENT_CATEGORY = CFG_MAX_LOGLEVEL
#endif
};
/**
* Structure to store and retrieve log event information.
* @see @ref secSLogEvents
*/
struct ndb_logevent {
/** NdbLogEventHandle (to be used for comparing only)
* set in ndb_logevent_get_next()
*/
void *handle;
/** Which event */
enum Ndb_logevent_type type;
/** Time when log event was registred at the management server */
unsigned time;
/** Category of log event */
enum ndb_mgm_event_category category;
/** Severity of log event */
enum ndb_mgm_event_severity severity;
/** Level (0-15) of log event */
unsigned level;
/** Node ID of the node that reported the log event */
unsigned source_nodeid;
/** Union of log event specific data. Use @ref type to decide
* which struct to use
*/
union {
/* CONNECT */
struct {
unsigned node;
} Connected;
struct {
unsigned node;
} Disconnected;
struct {
unsigned node;
} CommunicationClosed;
struct {
unsigned node;
} CommunicationOpened;
struct {
unsigned node;
unsigned version;
} ConnectedApiVersion;
/* CHECKPOINT */
struct {
unsigned gci;
} GlobalCheckpointStarted;
struct {
unsigned gci;
} GlobalCheckpointCompleted;
struct {
unsigned lci;
unsigned keep_gci;
unsigned restore_gci;
} LocalCheckpointStarted;
struct {
unsigned lci;
} LocalCheckpointCompleted;
struct {
unsigned data;
} LCPStoppedInCalcKeepGci;
struct {
unsigned node;
unsigned table_id;
unsigned fragment_id;
} LCPFragmentCompleted;
struct {
unsigned acc_count;
unsigned tup_count;
} UndoLogBlocked;
/* STARTUP */
struct {
unsigned version;
} NDBStartStarted;
struct {
unsigned version;
} NDBStartCompleted;
struct {
} STTORRYRecieved;
struct {
unsigned phase;
unsigned starttype;
} StartPhaseCompleted;
struct {
unsigned own_id;
unsigned president_id;
unsigned dynamic_id;
} CM_REGCONF;
struct {
unsigned own_id;
unsigned other_id;
unsigned cause;
} CM_REGREF;
struct {
unsigned own_id;
unsigned left_id;
unsigned right_id;
unsigned dynamic_id;
} FIND_NEIGHBOURS;
struct {
unsigned stoptype;
} NDBStopStarted;
struct {
} NDBStopAborted;
struct {
unsigned node;
unsigned keep_gci;
unsigned completed_gci;
unsigned restorable_gci;
} StartREDOLog;
struct {
unsigned log_part;
unsigned start_mb;
unsigned stop_mb;
unsigned gci;
} StartLog;
struct {
unsigned block;
unsigned data1;
unsigned data2;
unsigned data3;
unsigned data4;
unsigned data5;
unsigned data6;
unsigned data7;
unsigned data8;
unsigned data9;
unsigned data10;
} UNDORecordsExecuted;
/* NODERESTART */
struct {
} NR_CopyDict;
struct {
} NR_CopyDistr;
struct {
unsigned dest_node;
} NR_CopyFragsStarted;
struct {
unsigned dest_node;
unsigned table_id;
unsigned fragment_id;
} NR_CopyFragDone;
struct {
unsigned dest_node;
} NR_CopyFragsCompleted;
struct {
unsigned block; /* 0 = all */
unsigned failed_node;
unsigned completing_node; /* 0 = all */
} NodeFailCompleted;
struct {
unsigned failed_node;
unsigned failure_state;
} NODE_FAILREP;
struct {
/* TODO */
} ArbitState;
struct {
/* TODO */
} ArbitResult;
struct {
} GCP_TakeoverStarted;
struct {
} GCP_TakeoverCompleted;
struct {
} LCP_TakeoverStarted;
struct {
unsigned state;
} LCP_TakeoverCompleted;
/* STATISTIC */
struct {
unsigned trans_count;
unsigned commit_count;
unsigned read_count;
unsigned simple_read_count;
unsigned write_count;
unsigned attrinfo_count;
unsigned conc_op_count;
unsigned abort_count;
unsigned scan_count;
unsigned range_scan_count;
} TransReportCounters;
struct {
unsigned ops;
} OperationReportCounters;
struct {
unsigned table_id;
} TableCreated;
struct {
unsigned mean_loop_count;
} JobStatistic;
struct {
unsigned to_node;
unsigned mean_sent_bytes;
} SendBytesStatistic;
struct {
unsigned from_node;
unsigned mean_received_bytes;
} ReceiveBytesStatistic;
struct {
int gth;
unsigned page_size_kb;
unsigned pages_used;
unsigned pages_total;
unsigned block;
} MemoryUsage;
/* ERROR */
struct {
unsigned to_node;
unsigned code;
} TransporterError;
struct {
unsigned to_node;
unsigned code;
} TransporterWarning;
struct {
unsigned node;
unsigned count;
} MissedHeartbeat;
struct {
unsigned node;
} DeadDueToHeartbeat;
struct {
/* TODO */
} WarningEvent;
/* INFO */
struct {
unsigned node;
} SentHeartbeat;
struct {
unsigned node;
} CreateLogBytes;
struct {
/* TODO */
} InfoEvent;
/** Log event data for @ref NDB_LE_BackupStarted */
struct {
unsigned starting_node;
unsigned backup_id;
} BackupStarted;
/** Log event data @ref NDB_LE_BackupFailedToStart */
struct {
unsigned starting_node;
unsigned error;
} BackupFailedToStart;
/** Log event data @ref NDB_LE_BackupCompleted */
struct {
unsigned starting_node;
unsigned backup_id;
unsigned start_gci;
unsigned stop_gci;
unsigned n_records;
unsigned n_log_records;
unsigned n_bytes;
unsigned n_log_bytes;
} BackupCompleted;
/** Log event data @ref NDB_LE_BackupAborted */
struct {
unsigned starting_node;
unsigned backup_id;
unsigned error;
} BackupAborted;
#ifndef DOXYGEN_FIX
};
#else
} <union>;
#endif
};
enum ndb_logevent_handle_error {
NDB_LEH_NO_ERROR,
NDB_LEH_READ_ERROR,
NDB_LEH_MISSING_EVENT_SPECIFIER,
NDB_LEH_UNKNOWN_EVENT_TYPE,
NDB_LEH_UNKNOWN_EVENT_VARIABLE,
NDB_LEH_INTERNAL_ERROR
};
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
/** @} */
#endif #endif
ndb/src/common/debugger/EventLogger.cpp
View file @ 3f255881
...@@ -33,189 +33,84 @@ EventLoggerBase::~EventLoggerBase() ...@@ -33,189 +33,84 @@ EventLoggerBase::~EventLoggerBase()
} }
/**
* This matrix defines which event should be printed when
*
* threshold - is in range [0-15]
* severity - DEBUG to ALERT (Type of log message)
*/
const EventLoggerBase::EventRepLogLevelMatrix EventLoggerBase::matrix[] = {
// CONNECTION
{ NDB_LE_Connected, LogLevel::llConnection, 8, Logger::LL_INFO },
{ NDB_LE_Disconnected, LogLevel::llConnection, 8, Logger::LL_ALERT },
{ NDB_LE_CommunicationClosed, LogLevel::llConnection, 8, Logger::LL_INFO },
{ NDB_LE_CommunicationOpened, LogLevel::llConnection, 8, Logger::LL_INFO },
{ NDB_LE_ConnectedApiVersion, LogLevel::llConnection, 8, Logger::LL_INFO },
// CHECKPOINT
{ NDB_LE_GlobalCheckpointStarted, LogLevel::llCheckpoint, 9, Logger::LL_INFO },
{ NDB_LE_GlobalCheckpointCompleted,LogLevel::llCheckpoint,10, Logger::LL_INFO },
{ NDB_LE_LocalCheckpointStarted, LogLevel::llCheckpoint, 7, Logger::LL_INFO },
{ NDB_LE_LocalCheckpointCompleted,LogLevel::llCheckpoint, 8, Logger::LL_INFO },
{ NDB_LE_LCPStoppedInCalcKeepGci, LogLevel::llCheckpoint, 0, Logger::LL_ALERT },
{ NDB_LE_LCPFragmentCompleted, LogLevel::llCheckpoint, 11, Logger::LL_INFO },
{ NDB_LE_UndoLogBlocked, LogLevel::llCheckpoint, 7, Logger::LL_INFO },
// STARTUP
{ NDB_LE_NDBStartStarted, LogLevel::llStartUp, 1, Logger::LL_INFO },
{ NDB_LE_NDBStartCompleted, LogLevel::llStartUp, 1, Logger::LL_INFO },
{ NDB_LE_STTORRYRecieved, LogLevel::llStartUp,15, Logger::LL_INFO },
{ NDB_LE_StartPhaseCompleted, LogLevel::llStartUp, 4, Logger::LL_INFO },
{ NDB_LE_CM_REGCONF, LogLevel::llStartUp, 3, Logger::LL_INFO },
{ NDB_LE_CM_REGREF, LogLevel::llStartUp, 8, Logger::LL_INFO },
{ NDB_LE_FIND_NEIGHBOURS, LogLevel::llStartUp, 8, Logger::LL_INFO },
{ NDB_LE_NDBStopStarted, LogLevel::llStartUp, 1, Logger::LL_INFO },
{ NDB_LE_NDBStopAborted, LogLevel::llStartUp, 1, Logger::LL_INFO },
{ NDB_LE_StartREDOLog, LogLevel::llStartUp, 10, Logger::LL_INFO },
{ NDB_LE_StartLog, LogLevel::llStartUp, 10, Logger::LL_INFO },
{ NDB_LE_UNDORecordsExecuted, LogLevel::llStartUp, 15, Logger::LL_INFO },
// NODERESTART
{ NDB_LE_NR_CopyDict, LogLevel::llNodeRestart, 8, Logger::LL_INFO },
{ NDB_LE_NR_CopyDistr, LogLevel::llNodeRestart, 8, Logger::LL_INFO },
{ NDB_LE_NR_CopyFragsStarted, LogLevel::llNodeRestart, 8, Logger::LL_INFO },
{ NDB_LE_NR_CopyFragDone, LogLevel::llNodeRestart, 10, Logger::LL_INFO },
{ NDB_LE_NR_CopyFragsCompleted, LogLevel::llNodeRestart, 8, Logger::LL_INFO },
{ NDB_LE_NodeFailCompleted, LogLevel::llNodeRestart, 8, Logger::LL_ALERT},
{ NDB_LE_NODE_FAILREP, LogLevel::llNodeRestart, 8, Logger::LL_ALERT},
{ NDB_LE_ArbitState, LogLevel::llNodeRestart, 6, Logger::LL_INFO },
{ NDB_LE_ArbitResult, LogLevel::llNodeRestart, 2, Logger::LL_ALERT},
{ NDB_LE_GCP_TakeoverStarted, LogLevel::llNodeRestart, 7, Logger::LL_INFO },
{ NDB_LE_GCP_TakeoverCompleted, LogLevel::llNodeRestart, 7, Logger::LL_INFO },
{ NDB_LE_LCP_TakeoverStarted, LogLevel::llNodeRestart, 7, Logger::LL_INFO },
{ NDB_LE_LCP_TakeoverCompleted, LogLevel::llNodeRestart, 7, Logger::LL_INFO },
// STATISTIC
{ NDB_LE_TransReportCounters, LogLevel::llStatistic, 8, Logger::LL_INFO },
{ NDB_LE_OperationReportCounters, LogLevel::llStatistic, 8, Logger::LL_INFO },
{ NDB_LE_TableCreated, LogLevel::llStatistic, 7, Logger::LL_INFO },
{ NDB_LE_JobStatistic, LogLevel::llStatistic, 9, Logger::LL_INFO },
{ NDB_LE_SendBytesStatistic, LogLevel::llStatistic, 9, Logger::LL_INFO },
{ NDB_LE_ReceiveBytesStatistic, LogLevel::llStatistic, 9, Logger::LL_INFO },
{ NDB_LE_MemoryUsage, LogLevel::llStatistic, 5, Logger::LL_INFO },
// ERROR
{ NDB_LE_TransporterError, LogLevel::llError, 2, Logger::LL_ERROR },
{ NDB_LE_TransporterWarning, LogLevel::llError, 8, Logger::LL_WARNING },
{ NDB_LE_MissedHeartbeat, LogLevel::llError, 8, Logger::LL_WARNING },
{ NDB_LE_DeadDueToHeartbeat, LogLevel::llError, 8, Logger::LL_ALERT },
{ NDB_LE_WarningEvent, LogLevel::llError, 2, Logger::LL_WARNING },
// INFO
{ NDB_LE_SentHeartbeat, LogLevel::llInfo, 12, Logger::LL_INFO },
{ NDB_LE_CreateLogBytes, LogLevel::llInfo, 11, Logger::LL_INFO },
{ NDB_LE_InfoEvent, LogLevel::llInfo, 2, Logger::LL_INFO },
// Backup
{ NDB_LE_BackupStarted, LogLevel::llBackup, 7, Logger::LL_INFO },
{ NDB_LE_BackupCompleted, LogLevel::llBackup, 7, Logger::LL_INFO },
{ NDB_LE_BackupFailedToStart, LogLevel::llBackup, 7, Logger::LL_ALERT},
{ NDB_LE_BackupAborted, LogLevel::llBackup, 7, Logger::LL_ALERT }
};
const Uint32 EventLoggerBase::matrixSize = sizeof(EventLoggerBase::matrix)/
sizeof(EventRepLogLevelMatrix);
const char* #define QQQQ char *m_text, size_t m_text_len, const Uint32* theData
EventLogger::getText(char * m_text, size_t m_text_len,
int type,
const Uint32* theData, NodeId nodeId)
{
// TODO: Change the switch implementation...
char theNodeId[32];
if (nodeId != 0){
BaseString::snprintf(theNodeId, 32, "Node %u: ", nodeId);
} else {
theNodeId[0] = 0;
}
Ndb_logevent_type eventType = (Ndb_logevent_type)type; void getTextConnected(QQQQ) {
switch (eventType){
case NDB_LE_Connected:
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sNode %u Connected", "Node %u Connected",
theNodeId,
theData[1]); theData[1]);
break; }
case NDB_LE_ConnectedApiVersion: void getTextConnectedApiVersion(QQQQ) {
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sNode %u: API version %d.%d.%d", "Node %u: API version %d.%d.%d",
theNodeId,
theData[1], theData[1],
getMajor(theData[2]), getMajor(theData[2]),
getMinor(theData[2]), getMinor(theData[2]),
getBuild(theData[2])); getBuild(theData[2]));
break; }
case NDB_LE_Disconnected: void getTextDisconnected(QQQQ) {
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sNode %u Disconnected", "Node %u Disconnected",
theNodeId,
theData[1]); theData[1]);
break; }
case NDB_LE_CommunicationClosed: void getTextCommunicationClosed(QQQQ) {
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// REPORT communication to node closed. // REPORT communication to node closed.
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sCommunication to Node %u closed", "Communication to Node %u closed",
theNodeId,
theData[1]); theData[1]);
break; }
case NDB_LE_CommunicationOpened: void getTextCommunicationOpened(QQQQ) {
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// REPORT communication to node opened. // REPORT communication to node opened.
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sCommunication to Node %u opened", "Communication to Node %u opened",
theNodeId,
theData[1]); theData[1]);
break; }
case NDB_LE_NDBStartStarted: void getTextNDBStartStarted(QQQQ) {
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// Start of NDB has been initiated. // Start of NDB has been initiated.
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sStart initiated (version %d.%d.%d)", "Start initiated (version %d.%d.%d)",
theNodeId ,
getMajor(theData[1]), getMajor(theData[1]),
getMinor(theData[1]), getMinor(theData[1]),
getBuild(theData[1])); getBuild(theData[1]));
break; }
case NDB_LE_NDBStopStarted: void getTextNDBStopStarted(QQQQ) {
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%s%s shutdown initiated", "%s shutdown initiated",
theNodeId,
(theData[1] == 1 ? "Cluster" : "Node")); (theData[1] == 1 ? "Cluster" : "Node"));
break; }
case NDB_LE_NDBStopAborted: void getTextNDBStopAborted(QQQQ) {
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sNode shutdown aborted", "Node shutdown aborted");
theNodeId); }
break; void getTextNDBStartCompleted(QQQQ) {
case NDB_LE_NDBStartCompleted:
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// Start of NDB has been completed. // Start of NDB has been completed.
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sStarted (version %d.%d.%d)", "Started (version %d.%d.%d)",
theNodeId ,
getMajor(theData[1]), getMajor(theData[1]),
getMinor(theData[1]), getMinor(theData[1]),
getBuild(theData[1])); getBuild(theData[1]));
}
break; void getTextSTTORRYRecieved(QQQQ) {
case NDB_LE_STTORRYRecieved:
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// STTORRY recevied after restart finished. // STTORRY recevied after restart finished.
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sSTTORRY received after restart finished", "STTORRY received after restart finished");
theNodeId); }
break; void getTextStartPhaseCompleted(QQQQ) {
case NDB_LE_StartPhaseCompleted:{
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// REPORT Start phase completed. // REPORT Start phase completed.
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
const char * type = "<Unknown>"; const char *type = "<Unknown>";
switch((NodeState::StartType)theData[2]){ switch((NodeState::StartType)theData[2]){
case NodeState::ST_INITIAL_START: case NodeState::ST_INITIAL_START:
type = "(initial start)"; type = "(initial start)";
...@@ -232,34 +127,26 @@ EventLogger::getText(char * m_text, size_t m_text_len, ...@@ -232,34 +127,26 @@ EventLogger::getText(char * m_text, size_t m_text_len,
case NodeState::ST_ILLEGAL_TYPE: case NodeState::ST_ILLEGAL_TYPE:
type = ""; type = "";
break; break;
default:{ default:
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sStart phase %u completed (unknown = %d)", "Start phase %u completed (unknown = %d)",
theNodeId,
theData[1], theData[1],
theData[2]); theData[2]);
return m_text; return;
}
} }
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sStart phase %u completed %s", "Start phase %u completed %s",
theNodeId,
theData[1], theData[1],
type); type);
return m_text; }
break; void getTextCM_REGCONF(QQQQ) {
}
case NDB_LE_CM_REGCONF:
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sCM_REGCONF president = %u, own Node = %u, our dynamic id = %u" "CM_REGCONF president = %u, own Node = %u, our dynamic id = %u",
,
theNodeId,
theData[2], theData[2],
theData[1], theData[1],
theData[3]); theData[3]);
break; }
case NDB_LE_CM_REGREF: void getTextCM_REGREF(QQQQ) {
{
const char* line = ""; const char* line = "";
switch (theData[3]) { switch (theData[3]) {
case 0: case 0:
...@@ -283,28 +170,24 @@ EventLogger::getText(char * m_text, size_t m_text_len, ...@@ -283,28 +170,24 @@ EventLogger::getText(char * m_text, size_t m_text_len,
}//switch }//switch
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sCM_REGREF from Node %u to our Node %u. Cause = %s", "CM_REGREF from Node %u to our Node %u. Cause = %s",
theNodeId,
theData[2], theData[2],
theData[1], theData[1],
line); line);
} }
break; void getTextFIND_NEIGHBOURS(QQQQ) {
case NDB_LE_FIND_NEIGHBOURS:
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// REPORT Node Restart copied a fragment. // REPORT Node Restart copied a fragment.
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "We are Node %u with dynamic ID %u, our left neighbour "
"%sWe are Node %u with dynamic ID %u, our left neighbour "
"is Node %u, our right is Node %u", "is Node %u, our right is Node %u",
theNodeId,
theData[1], theData[1],
theData[4], theData[4],
theData[2], theData[2],
theData[3]); theData[3]);
break; }
case NDB_LE_NodeFailCompleted: void getTextNodeFailCompleted(QQQQ) {
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// REPORT Node failure phase completed. // REPORT Node failure phase completed.
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
...@@ -312,14 +195,12 @@ EventLogger::getText(char * m_text, size_t m_text_len, ...@@ -312,14 +195,12 @@ EventLogger::getText(char * m_text, size_t m_text_len,
{ {
if (theData[3] != 0) { if (theData[3] != 0) {
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sNode %u completed failure of Node %u", "Node %u completed failure of Node %u",
theNodeId,
theData[3], theData[3],
theData[2]); theData[2]);
} else { } else {
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sAll nodes completed failure of Node %u", "All nodes completed failure of Node %u",
theNodeId,
theData[2]); theData[2]);
}//if }//if
} else { } else {
...@@ -333,29 +214,25 @@ EventLogger::getText(char * m_text, size_t m_text_len, ...@@ -333,29 +214,25 @@ EventLogger::getText(char * m_text, size_t m_text_len,
}else if (theData[1] == DBLQH){ }else if (theData[1] == DBLQH){
line = "DBLQH"; line = "DBLQH";
} }
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sNode failure of %u %s completed", "Node failure of %u %s completed",
theNodeId,
theData[2], theData[2],
line); line);
} }
break; }
case NDB_LE_NODE_FAILREP: void getTextNODE_FAILREP(QQQQ) {
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Node %u has failed. The Node state at failure "
"%sNode %u has failed. The Node state at failure "
"was %u", "was %u",
theNodeId,
theData[1], theData[1],
theData[2]); theData[2]);
}
break; void getTextArbitState(QQQQ) {
case NDB_LE_ArbitState:
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// REPORT arbitrator found or lost. // REPORT arbitrator found or lost.
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
{ const ArbitSignalData* sd = (ArbitSignalData*)theData; {
const ArbitSignalData* sd = (ArbitSignalData*)theData;
char ticketText[ArbitTicket::TextLength + 1]; char ticketText[ArbitTicket::TextLength + 1];
char errText[ArbitCode::ErrTextLength + 1]; char errText[ArbitCode::ErrTextLength + 1];
const unsigned code = sd->code & 0xFFFF; const unsigned code = sd->code & 0xFFFF;
...@@ -363,242 +240,215 @@ EventLogger::getText(char * m_text, size_t m_text_len, ...@@ -363,242 +240,215 @@ EventLogger::getText(char * m_text, size_t m_text_len,
switch (code) { switch (code) {
case ArbitCode::ThreadStart: case ArbitCode::ThreadStart:
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sPresident restarts arbitration thread [state=%u]", "President restarts arbitration thread [state=%u]",
theNodeId, state); state);
break; break;
case ArbitCode::PrepPart2: case ArbitCode::PrepPart2:
sd->ticket.getText(ticketText, sizeof(ticketText)); sd->ticket.getText(ticketText, sizeof(ticketText));
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sPrepare arbitrator node %u [ticket=%s]", "Prepare arbitrator node %u [ticket=%s]",
theNodeId, sd->node, ticketText); sd->node, ticketText);
break; break;
case ArbitCode::PrepAtrun: case ArbitCode::PrepAtrun:
sd->ticket.getText(ticketText, sizeof(ticketText)); sd->ticket.getText(ticketText, sizeof(ticketText));
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sReceive arbitrator node %u [ticket=%s]", "Receive arbitrator node %u [ticket=%s]",
theNodeId, sd->node, ticketText); sd->node, ticketText);
break; break;
case ArbitCode::ApiStart: case ArbitCode::ApiStart:
sd->ticket.getText(ticketText, sizeof(ticketText)); sd->ticket.getText(ticketText, sizeof(ticketText));
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sStarted arbitrator node %u [ticket=%s]", "Started arbitrator node %u [ticket=%s]",
theNodeId, sd->node, ticketText); sd->node, ticketText);
break; break;
case ArbitCode::ApiFail: case ArbitCode::ApiFail:
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sLost arbitrator node %u - process failure [state=%u]", "Lost arbitrator node %u - process failure [state=%u]",
theNodeId, sd->node, state); sd->node, state);
break; break;
case ArbitCode::ApiExit: case ArbitCode::ApiExit:
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sLost arbitrator node %u - process exit [state=%u]", "Lost arbitrator node %u - process exit [state=%u]",
theNodeId, sd->node, state); sd->node, state);
break; break;
default: default:
ArbitCode::getErrText(code, errText, sizeof(errText)); ArbitCode::getErrText(code, errText, sizeof(errText));
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sLost arbitrator node %u - %s [state=%u]", "Lost arbitrator node %u - %s [state=%u]",
theNodeId, sd->node, errText, state); sd->node, errText, state);
break; break;
} }
} }
break; }
case NDB_LE_ArbitResult:
void getTextArbitResult(QQQQ) {
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// REPORT arbitration result (the failures may not reach us). // REPORT arbitration result (the failures may not reach us).
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
{ const ArbitSignalData* sd = (ArbitSignalData*)theData; {
const ArbitSignalData* sd = (ArbitSignalData*)theData;
char errText[ArbitCode::ErrTextLength + 1]; char errText[ArbitCode::ErrTextLength + 1];
const unsigned code = sd->code & 0xFFFF; const unsigned code = sd->code & 0xFFFF;
const unsigned state = sd->code >> 16; const unsigned state = sd->code >> 16;
switch (code) { switch (code) {
case ArbitCode::LoseNodes: case ArbitCode::LoseNodes:
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sArbitration check lost - less than 1/2 nodes left", "Arbitration check lost - less than 1/2 nodes left");
theNodeId);
break; break;
case ArbitCode::WinNodes: case ArbitCode::WinNodes:
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sArbitration check won - all node groups and more than 1/2 nodes left", "Arbitration check won - all node groups and more than 1/2 nodes left");
theNodeId);
break; break;
case ArbitCode::WinGroups: case ArbitCode::WinGroups:
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sArbitration check won - node group majority", "Arbitration check won - node group majority");
theNodeId);
break; break;
case ArbitCode::LoseGroups: case ArbitCode::LoseGroups:
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sArbitration check lost - missing node group", "Arbitration check lost - missing node group");
theNodeId);
break; break;
case ArbitCode::Partitioning: case ArbitCode::Partitioning:
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sNetwork partitioning - arbitration required", "Network partitioning - arbitration required");
theNodeId);
break; break;
case ArbitCode::WinChoose: case ArbitCode::WinChoose:
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sArbitration won - positive reply from node %u", "Arbitration won - positive reply from node %u",
theNodeId, sd->node); sd->node);
break; break;
case ArbitCode::LoseChoose: case ArbitCode::LoseChoose:
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sArbitration lost - negative reply from node %u", "Arbitration lost - negative reply from node %u",
theNodeId, sd->node); sd->node);
break; break;
case ArbitCode::LoseNorun: case ArbitCode::LoseNorun:
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sNetwork partitioning - no arbitrator available", "Network partitioning - no arbitrator available");
theNodeId);
break; break;
case ArbitCode::LoseNocfg: case ArbitCode::LoseNocfg:
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sNetwork partitioning - no arbitrator configured", "Network partitioning - no arbitrator configured");
theNodeId);
break; break;
default: default:
ArbitCode::getErrText(code, errText, sizeof(errText)); ArbitCode::getErrText(code, errText, sizeof(errText));
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sArbitration failure - %s [state=%u]", "Arbitration failure - %s [state=%u]",
theNodeId, errText, state); errText, state);
break; break;
} }
} }
break; }
case NDB_LE_GlobalCheckpointStarted: void getTextGlobalCheckpointStarted(QQQQ) {
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// This event reports that a global checkpoint has been started and this // This event reports that a global checkpoint has been started and this
// node is the master of this global checkpoint. // node is the master of this global checkpoint.
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Global checkpoint %u started",
"%sGlobal checkpoint %u started",
theNodeId,
theData[1]); theData[1]);
break; }
case NDB_LE_GlobalCheckpointCompleted: void getTextGlobalCheckpointCompleted(QQQQ) {
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// This event reports that a global checkpoint has been completed on this // This event reports that a global checkpoint has been completed on this
// node and the node is the master of this global checkpoint. // node and the node is the master of this global checkpoint.
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sGlobal checkpoint %u completed", "Global checkpoint %u completed",
theNodeId,
theData[1]); theData[1]);
break; }
case NDB_LE_LocalCheckpointStarted: void getTextLocalCheckpointStarted(QQQQ) {
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// This event reports that a local checkpoint has been started and this // This event reports that a local checkpoint has been started and this
// node is the master of this local checkpoint. // node is the master of this local checkpoint.
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Local checkpoint %u started. "
"%sLocal checkpoint %u started. "
"Keep GCI = %u oldest restorable GCI = %u", "Keep GCI = %u oldest restorable GCI = %u",
theNodeId,
theData[1], theData[1],
theData[2], theData[2],
theData[3]); theData[3]);
break; }
case NDB_LE_LocalCheckpointCompleted: void getTextLocalCheckpointCompleted(QQQQ) {
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// This event reports that a local checkpoint has been completed on this // This event reports that a local checkpoint has been completed on this
// node and the node is the master of this local checkpoint. // node and the node is the master of this local checkpoint.
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Local checkpoint %u completed",
"%sLocal checkpoint %u completed",
theNodeId,
theData[1]); theData[1]);
break; }
case NDB_LE_TableCreated: void getTextTableCreated(QQQQ) {
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// This event reports that a table has been created. // This event reports that a table has been created.
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sTable with ID = %u created", "Table with ID = %u created",
theNodeId,
theData[1]); theData[1]);
break; }
case NDB_LE_LCPStoppedInCalcKeepGci: /* STRANGE */
void getTextLCPStoppedInCalcKeepGci(QQQQ) {
if (theData[1] == 0) if (theData[1] == 0)
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sLocal Checkpoint stopped in CALCULATED_KEEP_GCI", "Local Checkpoint stopped in CALCULATED_KEEP_GCI");
theNodeId); }
break; void getTextNR_CopyDict(QQQQ) {
case NDB_LE_NR_CopyDict:
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// REPORT Node Restart completed copy of dictionary information. // REPORT Node Restart completed copy of dictionary information.
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Node restart completed copy of dictionary information");
"%sNode restart completed copy of dictionary information", }
theNodeId); void getTextNR_CopyDistr(QQQQ) {
break;
case NDB_LE_NR_CopyDistr:
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// REPORT Node Restart completed copy of distribution information. // REPORT Node Restart completed copy of distribution information.
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Node restart completed copy of distribution information");
"%sNode restart completed copy of distribution information", }
theNodeId); void getTextNR_CopyFragsStarted(QQQQ) {
break;
case NDB_LE_NR_CopyFragsStarted:
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// REPORT Node Restart is starting to copy the fragments. // REPORT Node Restart is starting to copy the fragments.
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Node restart starting to copy the fragments "
"%sNode restart starting to copy the fragments "
"to Node %u", "to Node %u",
theNodeId,
theData[1]); theData[1]);
break; }
case NDB_LE_NR_CopyFragDone: void getTextNR_CopyFragDone(QQQQ) {
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// REPORT Node Restart copied a fragment. // REPORT Node Restart copied a fragment.
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Table ID = %u, fragment ID = %u have been copied "
"%sTable ID = %u, fragment ID = %u have been copied "
"to Node %u", "to Node %u",
theNodeId,
theData[2], theData[2],
theData[3], theData[3],
theData[1]); theData[1]);
break; }
case NDB_LE_NR_CopyFragsCompleted: void getTextNR_CopyFragsCompleted(QQQQ) {
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Node restart completed copying the fragments "
"%sNode restart completed copying the fragments "
"to Node %u", "to Node %u",
theNodeId,
theData[1]); theData[1]);
break; }
case NDB_LE_LCPFragmentCompleted: void getTextLCPFragmentCompleted(QQQQ) {
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Table ID = %u, fragment ID = %u has completed LCP "
"%sTable ID = %u, fragment ID = %u has completed LCP "
"on Node %u", "on Node %u",
theNodeId,
theData[2], theData[2],
theData[3], theData[3],
theData[1]); theData[1]);
break; }
case NDB_LE_TransReportCounters: void getTextTransReportCounters(QQQQ) {
// ------------------------------------------------------------------- // -------------------------------------------------------------------
// Report information about transaction activity once per 10 seconds. // Report information about transaction activity once per 10 seconds.
// ------------------------------------------------------------------- // -------------------------------------------------------------------
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Trans. Count = %u, Commit Count = %u, "
"%sTrans. Count = %u, Commit Count = %u, "
"Read Count = %u, Simple Read Count = %u,\n" "Read Count = %u, Simple Read Count = %u,\n"
"Write Count = %u, AttrInfo Count = %u, " "Write Count = %u, AttrInfo Count = %u, "
"Concurrent Operations = %u, Abort Count = %u\n" "Concurrent Operations = %u, Abort Count = %u\n"
" Scans: %u Range scans: %u", " Scans: %u Range scans: %u",
theNodeId,
theData[1], theData[1],
theData[2], theData[2],
theData[3], theData[3],
...@@ -609,114 +459,93 @@ EventLogger::getText(char * m_text, size_t m_text_len, ...@@ -609,114 +459,93 @@ EventLogger::getText(char * m_text, size_t m_text_len,
theData[8], theData[8],
theData[9], theData[9],
theData[10]); theData[10]);
break; }
case NDB_LE_OperationReportCounters: void getTextOperationReportCounters(QQQQ) {
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%sOperations=%u", "Operations=%u",
theNodeId,
theData[1]); theData[1]);
break; }
case NDB_LE_UndoLogBlocked: void getTextUndoLogBlocked(QQQQ) {
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// REPORT Undo Logging blocked due to buffer near to overflow. // REPORT Undo Logging blocked due to buffer near to overflow.
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "ACC Blocked %u and TUP Blocked %u times last second",
"%sACC Blocked %u and TUP Blocked %u times last second",
theNodeId,
theData[1], theData[1],
theData[2]); theData[2]);
break; }
case NDB_LE_TransporterError: void getTextTransporterError(QQQQ) {
case NDB_LE_TransporterWarning: BaseString::snprintf(m_text, m_text_len,
BaseString::snprintf(m_text, "Transporter to node %d reported error 0x%x",
m_text_len,
"%sTransporter to node %d reported error 0x%x",
theNodeId,
theData[1], theData[1],
theData[2]); theData[2]);
break; }
case NDB_LE_MissedHeartbeat: void getTextTransporterWarning(QQQQ) {
getTextTransporterError(m_text, m_text_len, theData);
}
void getTextMissedHeartbeat(QQQQ) {
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// REPORT Undo Logging blocked due to buffer near to overflow. // REPORT Undo Logging blocked due to buffer near to overflow.
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Node %d missed heartbeat %d",
"%sNode %d missed heartbeat %d",
theNodeId,
theData[1], theData[1],
theData[2]); theData[2]);
break; }
case NDB_LE_DeadDueToHeartbeat: void getTextDeadDueToHeartbeat(QQQQ) {
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
// REPORT Undo Logging blocked due to buffer near to overflow. // REPORT Undo Logging blocked due to buffer near to overflow.
//----------------------------------------------------------------------- //-----------------------------------------------------------------------
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Node %d declared dead due to missed heartbeat",
"%sNode %d declared dead due to missed heartbeat",
theNodeId,
theData[1]); theData[1]);
break; }
case NDB_LE_JobStatistic: void getTextJobStatistic(QQQQ) {
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Mean loop Counter in doJob last 8192 times = %u",
"%sMean loop Counter in doJob last 8192 times = %u",
theNodeId,
theData[1]); theData[1]);
break; }
case NDB_LE_SendBytesStatistic: void getTextSendBytesStatistic(QQQQ) {
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Mean send size to Node = %d last 4096 sends = %u bytes",
"%sMean send size to Node = %d last 4096 sends = %u bytes",
theNodeId,
theData[1], theData[1],
theData[2]); theData[2]);
break; }
case NDB_LE_ReceiveBytesStatistic: void getTextReceiveBytesStatistic(QQQQ) {
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Mean receive size to Node = %d last 4096 sends = %u bytes",
"%sMean receive size to Node = %d last 4096 sends = %u bytes",
theNodeId,
theData[1], theData[1],
theData[2]); theData[2]);
break; }
case NDB_LE_SentHeartbeat: void getTextSentHeartbeat(QQQQ) {
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Node Sent Heartbeat to node = %d",
"%sNode Sent Heartbeat to node = %d",
theNodeId,
theData[1]); theData[1]);
break; }
case NDB_LE_CreateLogBytes: void getTextCreateLogBytes(QQQQ) {
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Log part %u, log file %u, MB %u",
"%sLog part %u, log file %u, MB %u",
theNodeId,
theData[1], theData[1],
theData[2], theData[2],
theData[3]); theData[3]);
break; }
case NDB_LE_StartLog: void getTextStartLog(QQQQ) {
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Log part %u, start MB %u, stop MB %u, last GCI, log exec %u",
"%sLog part %u, start MB %u, stop MB %u, last GCI, log exec %u",
theNodeId,
theData[1], theData[1],
theData[2], theData[2],
theData[3], theData[3],
theData[4]); theData[4]);
break; }
case NDB_LE_StartREDOLog: void getTextStartREDOLog(QQQQ) {
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Node: %d StartLog: [GCI Keep: %d LastCompleted: %d NewestRestorable: %d]",
"%sNode: %d StartLog: [GCI Keep: %d LastCompleted: %d NewestRestorable: %d]",
theNodeId,
theData[1], theData[1],
theData[2], theData[2],
theData[3], theData[3],
theData[4]); theData[4]);
break; }
case NDB_LE_UNDORecordsExecuted:{ void getTextUNDORecordsExecuted(QQQQ) {
const char* line = ""; const char* line = "";
if (theData[1] == DBTUP){ if (theData[1] == DBTUP){
line = "DBTUP"; line = "DBTUP";
...@@ -724,10 +553,8 @@ EventLogger::getText(char * m_text, size_t m_text_len, ...@@ -724,10 +553,8 @@ EventLogger::getText(char * m_text, size_t m_text_len,
line = "DBACC"; line = "DBACC";
} }
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, " UNDO %s %d [%d %d %d %d %d %d %d %d %d]",
"%s UNDO %s %d [%d %d %d %d %d %d %d %d %d]",
theNodeId,
line, line,
theData[2], theData[2],
theData[3], theData[3],
...@@ -739,44 +566,28 @@ EventLogger::getText(char * m_text, size_t m_text_len, ...@@ -739,44 +566,28 @@ EventLogger::getText(char * m_text, size_t m_text_len,
theData[9], theData[9],
theData[10], theData[10],
theData[11]); theData[11]);
} }
break; void getTextInfoEvent(QQQQ) {
case NDB_LE_InfoEvent: BaseString::snprintf(m_text, m_text_len, (char *)&theData[1]);
BaseString::snprintf(m_text, }
m_text_len, void getTextWarningEvent(QQQQ) {
"%s%s", BaseString::snprintf(m_text, m_text_len, (char *)&theData[1]);
theNodeId, }
(char *)&theData[1]); void getTextGCP_TakeoverStarted(QQQQ) {
break; BaseString::snprintf(m_text, m_text_len, "GCP Take over started");
case NDB_LE_WarningEvent: }
BaseString::snprintf(m_text, void getTextGCP_TakeoverCompleted(QQQQ) {
m_text_len, BaseString::snprintf(m_text, m_text_len, "GCP Take over completed");
"%s%s", }
theNodeId, void getTextLCP_TakeoverStarted(QQQQ) {
(char *)&theData[1]); BaseString::snprintf(m_text, m_text_len, "LCP Take over started");
break; }
case NDB_LE_GCP_TakeoverStarted: void getTextLCP_TakeoverCompleted(QQQQ) {
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "LCP Take over completed (state = %d)",
"%sGCP Take over started", theNodeId); theData[1]);
break; }
case NDB_LE_GCP_TakeoverCompleted: void getTextMemoryUsage(QQQQ) {
BaseString::snprintf(m_text,
m_text_len,
"%sGCP Take over completed", theNodeId);
break;
case NDB_LE_LCP_TakeoverStarted:
BaseString::snprintf(m_text,
m_text_len,
"%sLCP Take over started", theNodeId);
break;
case NDB_LE_LCP_TakeoverCompleted:
BaseString::snprintf(m_text,
m_text_len,
"%sLCP Take over completed (state = %d)",
theNodeId, theData[1]);
break;
case NDB_LE_MemoryUsage:{
const int gth = theData[1]; const int gth = theData[1];
const int size = theData[2]; const int size = theData[2];
const int used = theData[3]; const int used = theData[3];
...@@ -785,524 +596,134 @@ EventLogger::getText(char * m_text, size_t m_text_len, ...@@ -785,524 +596,134 @@ EventLogger::getText(char * m_text, size_t m_text_len,
const int percent = (used*100)/total; const int percent = (used*100)/total;
BaseString::snprintf(m_text, m_text_len, BaseString::snprintf(m_text, m_text_len,
"%s%s usage %s %d%s(%d %dK pages of total %d)", "%s usage %s %d%s(%d %dK pages of total %d)",
theNodeId,
(block==DBACC ? "Index" : (block == DBTUP ?"Data":"<unknown>")), (block==DBACC ? "Index" : (block == DBTUP ?"Data":"<unknown>")),
(gth == 0 ? "is" : (gth > 0 ? "increased to" : "decreased to")), (gth == 0 ? "is" : (gth > 0 ? "increased to" : "decreased to")),
percent, "%", percent, "%",
used, size/1024, total used, size/1024, total
); );
break; }
}
case NDB_LE_GrepSubscriptionInfo :
{
GrepEvent::Subscription event = (GrepEvent::Subscription)theData[1];
switch(event) {
case GrepEvent::GrepSS_CreateSubIdConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Created subscription id"
" (subId=%d,SubKey=%d)"
" Return code: %d.",
subId,
subKey,
err);
break;
}
case GrepEvent::GrepPS_CreateSubIdConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: Created subscription id"
" (subId=%d,SubKey=%d)"
" Return code: %d.",
subId,
subKey,
err);
break;
}
case GrepEvent::GrepSS_SubCreateConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
const int nodegrp = theData[5];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Created subscription using"
" (subId=%d,SubKey=%d)"
" in primary system. Primary system has %d nodegroup(s)."
" Return code: %d",
subId,
subKey,
nodegrp,
err);
break;
}
case GrepEvent::GrepPS_SubCreateConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: All participants have created "
"subscriptions"
" using (subId=%d,SubKey=%d)."
" Return code: %d",
subId,
subKey,
err);
break;
}
case GrepEvent::GrepSS_SubStartMetaConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Logging started on meta data changes."
" using (subId=%d,SubKey=%d)"
" Return code: %d",
subId,
subKey,
err);
break;
}
case GrepEvent::GrepPS_SubStartMetaConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: All participants have started "
"logging meta data"
" changes on the subscription subId=%d,SubKey=%d) "
"(N.I yet)."
" Return code: %d",
subId,
subKey,
err);
break;
}
case GrepEvent::GrepSS_SubStartDataConf: {
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Logging started on table data changes "
" using (subId=%d,SubKey=%d)"
" Return code: %d",
subId,
subKey,
err);
break;
}
case GrepEvent::GrepPS_SubStartDataConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: All participants have started logging "
"table data changes on the subscription "
"subId=%d,SubKey=%d)."
" Return code: %d",
subId,
subKey,
err);
break;
}
case GrepEvent::GrepPS_SubSyncMetaConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: All participants have started "
" synchronization on meta data (META SCAN) using "
"(subId=%d,SubKey=%d)."
" Return code: %d",
subId,
subKey,
err);
break;
}
case GrepEvent::GrepSS_SubSyncMetaConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Synchronization started (META SCAN) on "
" meta data using (subId=%d,SubKey=%d)"
" Return code: %d",
subId,
subKey,
err);
break;
}
case GrepEvent::GrepPS_SubSyncDataConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: All participants have started "
"synchronization "
" on table data (DATA SCAN) using (subId=%d,SubKey=%d)."
" Return code: %d",
subId,
subKey,
err);
break;
}
case GrepEvent::GrepSS_SubSyncDataConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
const int gci = theData[5];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Synchronization started (DATA SCAN) on "
"table data using (subId=%d,SubKey=%d). GCI = %d"
" Return code: %d",
subId,
subKey,
gci,
err);
break;
}
case GrepEvent::GrepPS_SubRemoveConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: All participants have removed "
"subscription (subId=%d,SubKey=%d). I have cleaned "
"up resources I've used."
" Return code: %d",
subId,
subKey,
err);
break;
}
case GrepEvent::GrepSS_SubRemoveConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Removed subscription "
"(subId=%d,SubKey=%d)"
" Return code: %d",
subId,
subKey,
err);
break;
}
default:
BaseString::snprintf(m_text,
m_text_len,
"%sUnknown GrepSubscriptonInfo event: %d",
theNodeId,
theData[1]);
}
break;
}
case NDB_LE_GrepSubscriptionAlert :
{
GrepEvent::Subscription event = (GrepEvent::Subscription)theData[1];
switch(event)
{
case GrepEvent::GrepSS_CreateSubIdRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord:Error code: %d Error message: %s"
" (subId=%d,SubKey=%d)",
err,
GrepError::getErrorDesc((GrepError::GE_Code)err),
subId,
subKey);
break;
}
case GrepEvent::GrepSS_SubCreateRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: FAILED to Created subscription using"
" (subId=%d,SubKey=%d)in primary system."
" Error code: %d Error Message: %s",
subId,
subKey,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
case GrepEvent::GrepSS_SubStartMetaRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Logging failed to start on meta "
"data changes."
" using (subId=%d,SubKey=%d)"
" Error code: %d Error Message: %s",
subId,
subKey,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
case GrepEvent::GrepSS_SubStartDataRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Logging FAILED to start on table data "
" changes using (subId=%d,SubKey=%d)"
" Error code: %d Error Message: %s",
subId,
subKey,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
case GrepEvent::GrepSS_SubSyncMetaRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Synchronization FAILED (META SCAN) on "
" meta data using (subId=%d,SubKey=%d)"
" Error code: %d Error Message: %s",
subId,
subKey,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
case GrepEvent::GrepSS_SubSyncDataRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
const int gci = theData[5];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Synchronization FAILED (DATA SCAN) on "
"table data using (subId=%d,SubKey=%d). GCI = %d"
" Error code: %d Error Message: %s",
subId,
subKey,
gci,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
case GrepEvent::GrepSS_SubRemoveRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Failed to remove subscription "
"(subId=%d,SubKey=%d). "
" Error code: %d Error Message: %s",
subId,
subKey,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err)
);
break;
}
case GrepEvent::GrepPS_CreateSubIdRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: Error code: %d Error Message: %s"
" (subId=%d,SubKey=%d)",
err,
GrepError::getErrorDesc((GrepError::GE_Code)err),
subId,
subKey);
break;
}
case GrepEvent::GrepPS_SubCreateRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: FAILED to Created subscription using"
" (subId=%d,SubKey=%d)in primary system."
" Error code: %d Error Message: %s",
subId,
subKey,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
case GrepEvent::GrepPS_SubStartMetaRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: Logging failed to start on meta "
"data changes."
" using (subId=%d,SubKey=%d)"
" Error code: %d Error Message: %s",
subId,
subKey,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
case GrepEvent::GrepPS_SubStartDataRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: Logging FAILED to start on table data "
" changes using (subId=%d,SubKey=%d)"
" Error code: %d Error Message: %s",
subId,
subKey,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
case GrepEvent::GrepPS_SubSyncMetaRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: Synchronization FAILED (META SCAN) on "
" meta data using (subId=%d,SubKey=%d)"
" Error code: %d Error Message: %s",
subId,
subKey,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
case GrepEvent::GrepPS_SubSyncDataRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
const int gci = theData[5];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: Synchronization FAILED (DATA SCAN) on "
"table data using (subId=%d,SubKey=%d). GCI = %d. "
" Error code: %d Error Message: %s",
subId,
subKey,
gci,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
case GrepEvent::GrepPS_SubRemoveRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: Failed to remove subscription "
"(subId=%d,SubKey=%d)."
" Error code: %d Error Message: %s",
subId,
subKey,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
case GrepEvent::Rep_Disconnect:
{
const int err = theData[4];
const int nodeId = theData[5];
BaseString::snprintf(m_text, m_text_len,
"Rep: Node %d."
" Error code: %d Error Message: %s",
nodeId,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
default:
BaseString::snprintf(m_text,
m_text_len,
"%sUnknown GrepSubscriptionAlert event: %d",
theNodeId,
theData[1]);
break;
}
break;
}
case NDB_LE_BackupStarted: void getTextBackupStarted(QQQQ) {
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Backup %d started from node %d",
"%sBackup %d started from node %d", theData[2], refToNode(theData[1]));
theNodeId, theData[2], refToNode(theData[1])); }
break; void getTextBackupFailedToStart(QQQQ) {
case NDB_LE_BackupFailedToStart: BaseString::snprintf(m_text, m_text_len,
BaseString::snprintf(m_text, "Backup request from %d failed to start. Error: %d",
m_text_len, refToNode(theData[1]), theData[2]);
"%sBackup request from %d failed to start. Error: %d", }
theNodeId, refToNode(theData[1]), theData[2]); void getTextBackupCompleted(QQQQ) {
break; BaseString::snprintf(m_text, m_text_len,
case NDB_LE_BackupCompleted: "Backup %u started from node %u completed\n"
BaseString::snprintf(m_text,
m_text_len,
"%sBackup %u started from node %u completed\n"
" StartGCP: %u StopGCP: %u\n" " StartGCP: %u StopGCP: %u\n"
" #Records: %u #LogRecords: %u\n" " #Records: %u #LogRecords: %u\n"
" Data: %u bytes Log: %u bytes", " Data: %u bytes Log: %u bytes",
theNodeId, theData[2], refToNode(theData[1]), theData[2], refToNode(theData[1]),
theData[3], theData[4], theData[6], theData[8], theData[3], theData[4], theData[6], theData[8],
theData[5], theData[7]); theData[5], theData[7]);
break; }
case NDB_LE_BackupAborted: void getTextBackupAborted(QQQQ) {
BaseString::snprintf(m_text, BaseString::snprintf(m_text, m_text_len,
m_text_len, "Backup %d started from %d has been aborted. Error: %d",
"%sBackup %d started from %d has been aborted. Error: %d",
theNodeId,
theData[2], theData[2],
refToNode(theData[1]), refToNode(theData[1]),
theData[3]); theData[3]);
break; }
default:
BaseString::snprintf(m_text, #if 0
BaseString::snprintf(m_text,
m_text_len, m_text_len,
"%sUnknown event: %d", "Unknown event: %d",
theNodeId,
theData[0]); theData[0]);
#endif
} /**
return m_text; * This matrix defines which event should be printed when
} *
* threshold - is in range [0-15]
* severity - DEBUG to ALERT (Type of log message)
*/
#define ROW(a,b,c,d) \
{ NDB_LE_ ## a, b, c, d, getText ## a}
const EventLoggerBase::EventRepLogLevelMatrix EventLoggerBase::matrix[] = {
// CONNECTION
ROW(Connected, LogLevel::llConnection, 8, Logger::LL_INFO ),
ROW(Disconnected, LogLevel::llConnection, 8, Logger::LL_ALERT ),
ROW(CommunicationClosed, LogLevel::llConnection, 8, Logger::LL_INFO ),
ROW(CommunicationOpened, LogLevel::llConnection, 8, Logger::LL_INFO ),
ROW(ConnectedApiVersion, LogLevel::llConnection, 8, Logger::LL_INFO ),
// CHECKPOINT
ROW(GlobalCheckpointStarted, LogLevel::llCheckpoint, 9, Logger::LL_INFO ),
ROW(GlobalCheckpointCompleted,LogLevel::llCheckpoint,10, Logger::LL_INFO ),
ROW(LocalCheckpointStarted, LogLevel::llCheckpoint, 7, Logger::LL_INFO ),
ROW(LocalCheckpointCompleted,LogLevel::llCheckpoint, 8, Logger::LL_INFO ),
ROW(LCPStoppedInCalcKeepGci, LogLevel::llCheckpoint, 0, Logger::LL_ALERT ),
ROW(LCPFragmentCompleted, LogLevel::llCheckpoint, 11, Logger::LL_INFO ),
ROW(UndoLogBlocked, LogLevel::llCheckpoint, 7, Logger::LL_INFO ),
// STARTUP
ROW(NDBStartStarted, LogLevel::llStartUp, 1, Logger::LL_INFO ),
ROW(NDBStartCompleted, LogLevel::llStartUp, 1, Logger::LL_INFO ),
ROW(STTORRYRecieved, LogLevel::llStartUp, 15, Logger::LL_INFO ),
ROW(StartPhaseCompleted, LogLevel::llStartUp, 4, Logger::LL_INFO ),
ROW(CM_REGCONF, LogLevel::llStartUp, 3, Logger::LL_INFO ),
ROW(CM_REGREF, LogLevel::llStartUp, 8, Logger::LL_INFO ),
ROW(FIND_NEIGHBOURS, LogLevel::llStartUp, 8, Logger::LL_INFO ),
ROW(NDBStopStarted, LogLevel::llStartUp, 1, Logger::LL_INFO ),
ROW(NDBStopAborted, LogLevel::llStartUp, 1, Logger::LL_INFO ),
ROW(StartREDOLog, LogLevel::llStartUp, 10, Logger::LL_INFO ),
ROW(StartLog, LogLevel::llStartUp, 10, Logger::LL_INFO ),
ROW(UNDORecordsExecuted, LogLevel::llStartUp, 15, Logger::LL_INFO ),
// NODERESTART
ROW(NR_CopyDict, LogLevel::llNodeRestart, 8, Logger::LL_INFO ),
ROW(NR_CopyDistr, LogLevel::llNodeRestart, 8, Logger::LL_INFO ),
ROW(NR_CopyFragsStarted, LogLevel::llNodeRestart, 8, Logger::LL_INFO ),
ROW(NR_CopyFragDone, LogLevel::llNodeRestart,10, Logger::LL_INFO ),
ROW(NR_CopyFragsCompleted, LogLevel::llNodeRestart, 8, Logger::LL_INFO ),
ROW(NodeFailCompleted, LogLevel::llNodeRestart, 8, Logger::LL_ALERT),
ROW(NODE_FAILREP, LogLevel::llNodeRestart, 8, Logger::LL_ALERT),
ROW(ArbitState, LogLevel::llNodeRestart, 6, Logger::LL_INFO ),
ROW(ArbitResult, LogLevel::llNodeRestart, 2, Logger::LL_ALERT),
ROW(GCP_TakeoverStarted, LogLevel::llNodeRestart, 7, Logger::LL_INFO ),
ROW(GCP_TakeoverCompleted, LogLevel::llNodeRestart, 7, Logger::LL_INFO ),
ROW(LCP_TakeoverStarted, LogLevel::llNodeRestart, 7, Logger::LL_INFO ),
ROW(LCP_TakeoverCompleted, LogLevel::llNodeRestart, 7, Logger::LL_INFO ),
// STATISTIC
ROW(TransReportCounters, LogLevel::llStatistic, 8, Logger::LL_INFO ),
ROW(OperationReportCounters, LogLevel::llStatistic, 8, Logger::LL_INFO ),
ROW(TableCreated, LogLevel::llStatistic, 7, Logger::LL_INFO ),
ROW(JobStatistic, LogLevel::llStatistic, 9, Logger::LL_INFO ),
ROW(SendBytesStatistic, LogLevel::llStatistic, 9, Logger::LL_INFO ),
ROW(ReceiveBytesStatistic, LogLevel::llStatistic, 9, Logger::LL_INFO ),
ROW(MemoryUsage, LogLevel::llStatistic, 5, Logger::LL_INFO ),
// ERROR
ROW(TransporterError, LogLevel::llError, 2, Logger::LL_ERROR ),
ROW(TransporterWarning, LogLevel::llError, 8, Logger::LL_WARNING ),
ROW(MissedHeartbeat, LogLevel::llError, 8, Logger::LL_WARNING ),
ROW(DeadDueToHeartbeat, LogLevel::llError, 8, Logger::LL_ALERT ),
ROW(WarningEvent, LogLevel::llError, 2, Logger::LL_WARNING ),
// INFO
ROW(SentHeartbeat, LogLevel::llInfo, 12, Logger::LL_INFO ),
ROW(CreateLogBytes, LogLevel::llInfo, 11, Logger::LL_INFO ),
ROW(InfoEvent, LogLevel::llInfo, 2, Logger::LL_INFO ),
// Backup
ROW(BackupStarted, LogLevel::llBackup, 7, Logger::LL_INFO ),
ROW(BackupCompleted, LogLevel::llBackup, 7, Logger::LL_INFO ),
ROW(BackupFailedToStart, LogLevel::llBackup, 7, Logger::LL_ALERT),
ROW(BackupAborted, LogLevel::llBackup, 7, Logger::LL_ALERT )
};
const Uint32 EventLoggerBase::matrixSize=
sizeof(EventLoggerBase::matrix)/sizeof(EventRepLogLevelMatrix);
EventLogger::EventLogger() : m_filterLevel(15) EventLogger::EventLogger() : m_filterLevel(15)
{ {
...@@ -1342,19 +763,36 @@ int ...@@ -1342,19 +763,36 @@ int
EventLoggerBase::event_lookup(int eventType, EventLoggerBase::event_lookup(int eventType,
LogLevel::EventCategory &cat, LogLevel::EventCategory &cat,
Uint32 &threshold, Uint32 &threshold,
Logger::LoggerLevel &severity) Logger::LoggerLevel &severity,
EventTextFunction &textF)
{ {
for(unsigned i = 0; i<EventLoggerBase::matrixSize; i++){ for(unsigned i = 0; i<EventLoggerBase::matrixSize; i++){
if(EventLoggerBase::matrix[i].eventType == eventType){ if(EventLoggerBase::matrix[i].eventType == eventType){
cat = EventLoggerBase::matrix[i].eventCategory; cat = EventLoggerBase::matrix[i].eventCategory;
threshold = EventLoggerBase::matrix[i].threshold; threshold = EventLoggerBase::matrix[i].threshold;
severity = EventLoggerBase::matrix[i].severity; severity = EventLoggerBase::matrix[i].severity;
textF= EventLoggerBase::matrix[i].textF;
return 0; return 0;
} }
} }
return 1; return 1;
} }
const char*
EventLogger::getText(char * dst, size_t dst_len,
EventTextFunction textF,
const Uint32* theData, NodeId nodeId )
{
int pos= 0;
if (nodeId != 0)
{
BaseString::snprintf(dst, dst_len, "Node %u: ", nodeId);
pos= strlen(dst);
}
textF(dst,dst_len,theData);
return dst;
}
void void
EventLogger::log(int eventType, const Uint32* theData, NodeId nodeId, EventLogger::log(int eventType, const Uint32* theData, NodeId nodeId,
const LogLevel* ll) const LogLevel* ll)
...@@ -1362,52 +800,43 @@ EventLogger::log(int eventType, const Uint32* theData, NodeId nodeId, ...@@ -1362,52 +800,43 @@ EventLogger::log(int eventType, const Uint32* theData, NodeId nodeId,
Uint32 threshold = 0; Uint32 threshold = 0;
Logger::LoggerLevel severity = Logger::LL_WARNING; Logger::LoggerLevel severity = Logger::LL_WARNING;
LogLevel::EventCategory cat= LogLevel::llInvalid; LogLevel::EventCategory cat= LogLevel::llInvalid;
EventTextFunction textF;
DBUG_ENTER("EventLogger::log"); DBUG_ENTER("EventLogger::log");
DBUG_PRINT("enter",("eventType=%d, nodeid=%d", eventType, nodeId)); DBUG_PRINT("enter",("eventType=%d, nodeid=%d", eventType, nodeId));
if (EventLoggerBase::event_lookup(eventType,cat,threshold,severity)) if (EventLoggerBase::event_lookup(eventType,cat,threshold,severity,textF))
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
Uint32 set = ll?ll->getLogLevel(cat) : m_logLevel.getLogLevel(cat); Uint32 set = ll?ll->getLogLevel(cat) : m_logLevel.getLogLevel(cat);
DBUG_PRINT("info",("threshold=%d, set=%d", threshold, set)); DBUG_PRINT("info",("threshold=%d, set=%d", threshold, set));
if (ll) if (ll)
DBUG_PRINT("info",("m_logLevel.getLogLevel=%d", m_logLevel.getLogLevel(cat))); DBUG_PRINT("info",("m_logLevel.getLogLevel=%d", m_logLevel.getLogLevel(cat)));
if (threshold <= set){ if (threshold <= set){
getText(m_text,sizeof(m_text),textF,theData,nodeId);
switch (severity){ switch (severity){
case Logger::LL_ALERT: case Logger::LL_ALERT:
alert(EventLogger::getText(m_text, sizeof(m_text), alert(m_text);
eventType, theData, nodeId));
break; break;
case Logger::LL_CRITICAL: case Logger::LL_CRITICAL:
critical(EventLogger::getText(m_text, sizeof(m_text), critical(m_text);
eventType, theData, nodeId));
break; break;
case Logger::LL_WARNING: case Logger::LL_WARNING:
warning(EventLogger::getText(m_text, sizeof(m_text), warning(m_text);
eventType, theData, nodeId));
break; break;
case Logger::LL_ERROR: case Logger::LL_ERROR:
error(EventLogger::getText(m_text, sizeof(m_text), error(m_text);
eventType, theData, nodeId));
break; break;
case Logger::LL_INFO: case Logger::LL_INFO:
info(EventLogger::getText(m_text, sizeof(m_text), info(m_text);
eventType, theData, nodeId));
break; break;
case Logger::LL_DEBUG: case Logger::LL_DEBUG:
debug(EventLogger::getText(m_text, sizeof(m_text), debug(m_text);
eventType, theData, nodeId));
break; break;
default: default:
info(EventLogger::getText(m_text, sizeof(m_text), info(m_text);
eventType, theData, nodeId));
break; break;
} }
} // if (.. } // if (..
......
ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp
View file @ 3f255881
...@@ -198,7 +198,8 @@ void Cmvmi::execEVENT_REP(Signal* signal) ...@@ -198,7 +198,8 @@ void Cmvmi::execEVENT_REP(Signal* signal)
Uint32 threshold; Uint32 threshold;
LogLevel::EventCategory eventCategory; LogLevel::EventCategory eventCategory;
Logger::LoggerLevel severity; Logger::LoggerLevel severity;
if (EventLoggerBase::event_lookup(eventType,eventCategory,threshold,severity)) EventLoggerBase::EventTextFunction textF;
if (EventLoggerBase::event_lookup(eventType,eventCategory,threshold,severity,textF))
return; return;
SubscriberPtr ptr; SubscriberPtr ptr;
......
ndb/src/mgmapi/Makefile.am
View file @ 3f255881
noinst_LTLIBRARIES = libmgmapi.la noinst_LTLIBRARIES = libmgmapi.la
libmgmapi_la_SOURCES = mgmapi.cpp mgmapi_configuration.cpp LocalConfig.cpp libmgmapi_la_SOURCES = mgmapi.cpp ndb_logevent.cpp mgmapi_configuration.cpp LocalConfig.cpp
INCLUDES_LOC = -I$(top_srcdir)/ndb/include/mgmapi INCLUDES_LOC = -I$(top_srcdir)/ndb/include/mgmapi
......
ndb/src/mgmapi/mgmapi.cpp
View file @ 3f255881
...@@ -22,8 +22,8 @@ ...@@ -22,8 +22,8 @@
#include <NdbSleep.h> #include <NdbSleep.h>
#include <NdbTCP.h> #include <NdbTCP.h>
#include "mgmapi.h" #include <mgmapi.h>
#include "mgmapi_debug.h" #include <mgmapi_debug.h>
#include "mgmapi_configuration.hpp" #include "mgmapi_configuration.hpp"
#include <socket_io.h> #include <socket_io.h>
...@@ -1156,9 +1156,9 @@ ndb_mgm_set_loglevel_node(NdbMgmHandle handle, int nodeId, ...@@ -1156,9 +1156,9 @@ ndb_mgm_set_loglevel_node(NdbMgmHandle handle, int nodeId,
return 0; return 0;
} }
extern "C"
int int
ndb_mgm_listen_event(NdbMgmHandle handle, const int filter[]) ndb_mgm_listen_event_internal(NdbMgmHandle handle, const int filter[],
int structured)
{ {
SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_listen_event"); SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_listen_event");
const ParserRow<ParserDummy> stat_reply[] = { const ParserRow<ParserDummy> stat_reply[] = {
...@@ -1180,6 +1180,8 @@ ndb_mgm_listen_event(NdbMgmHandle handle, const int filter[]) ...@@ -1180,6 +1180,8 @@ ndb_mgm_listen_event(NdbMgmHandle handle, const int filter[])
} }
Properties args; Properties args;
args.put("structured", structured);
{ {
BaseString tmp; BaseString tmp;
for(int i = 0; filter[i] != 0; i += 2){ for(int i = 0; filter[i] != 0; i += 2){
...@@ -1203,6 +1205,13 @@ ndb_mgm_listen_event(NdbMgmHandle handle, const int filter[]) ...@@ -1203,6 +1205,13 @@ ndb_mgm_listen_event(NdbMgmHandle handle, const int filter[])
return sockfd; return sockfd;
} }
extern "C"
int
ndb_mgm_listen_event(NdbMgmHandle handle, const int filter[])
{
return ndb_mgm_listen_event_internal(handle,filter,0);
}
extern "C" extern "C"
int int
ndb_mgm_get_stat_port(NdbMgmHandle handle, struct ndb_mgm_reply* /*reply*/) ndb_mgm_get_stat_port(NdbMgmHandle handle, struct ndb_mgm_reply* /*reply*/)
...@@ -2138,5 +2147,4 @@ ndb_mgm_get_connection_int_parameter(NdbMgmHandle handle, ...@@ -2138,5 +2147,4 @@ ndb_mgm_get_connection_int_parameter(NdbMgmHandle handle,
DBUG_RETURN(res); DBUG_RETURN(res);
} }
template class Vector<const ParserRow<ParserDummy>*>; template class Vector<const ParserRow<ParserDummy>*>;
ndb/src/mgmapi/mgmapi_configuration.hpp
View file @ 3f255881
/* Copyright (C) 2003 MySQL AB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
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.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
#ifndef MGMAPI_CONFIGURATION_HPP #ifndef MGMAPI_CONFIGURATION_HPP
#define MGMAPI_CONFIGURATION_HPP #define MGMAPI_CONFIGURATION_HPP
......
ndb/src/mgmapi/ndb_logevent.cpp 0 → 100644
View file @ 3f255881
/* Copyright (C) 2003 MySQL AB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
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.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
#include <ndb_global.h>
#include <my_sys.h>
#include <mgmapi.h>
#include <NdbOut.hpp>
#include <Properties.hpp>
#include <socket_io.h>
#include <InputStream.hpp>
#include <debugger/EventLogger.hpp>
#include "ndb_logevent.hpp"
extern
int ndb_mgm_listen_event_internal(NdbMgmHandle, const int filter[], int);
struct ndb_logevent_error_msg {
enum ndb_logevent_handle_error code;
const char *msg;
};
struct ndb_logevent_error_msg ndb_logevent_error_messages[]= {
{ NDB_LEH_READ_ERROR, "Read error" },
{ NDB_LEH_MISSING_EVENT_SPECIFIER, "Missing event specifier" },
{ NDB_LEH_UNKNOWN_EVENT_VARIABLE, "Unknown event variable" },
{ NDB_LEH_UNKNOWN_EVENT_TYPE, "Unknown event type" },
{ NDB_LEH_INTERNAL_ERROR, "Unknown internal error" },
{ NDB_LEH_NO_ERROR,0}
};
struct ndb_logevent_handle {
NDB_SOCKET_TYPE socket;
enum ndb_logevent_handle_error m_error;
};
extern "C"
NdbLogEventHandle
ndb_mgm_create_logevent_handle(NdbMgmHandle mh,
const int filter[])
{
int fd= ndb_mgm_listen_event_internal(mh, filter, 1);
if (fd == -1)
return 0;
NdbLogEventHandle h=
(NdbLogEventHandle)my_malloc(sizeof(ndb_logevent_handle),MYF(MY_WME));
h->socket= fd;
return h;
}
extern "C"
void ndb_mgm_destroy_logevent_handle(NdbLogEventHandle * h)
{
if( !h )
return;
if ( *h )
close((*h)->socket);
my_free((char*)* h,MYF(MY_ALLOW_ZERO_PTR));
* h = 0;
}
#define ROW(a,b,c,d) \
{ NDB_LE_ ## a, b, c, 0, offsetof(struct ndb_logevent, a.d), \
sizeof(((struct ndb_logevent *)0)->a.d) }
#define ROW_FN(a,b,c,d,e) \
{ NDB_LE_ ## a, b, c, e, offsetof(struct ndb_logevent, a.d), \
sizeof(((struct ndb_logevent *)0)->a.d) }
static int ref_to_node(int ref){
return ref & 0xFFFF;
}
struct Ndb_logevent_body_row ndb_logevent_body[]= {
// Connection
ROW( Connected, "node", 1, node),
ROW( Disconnected, "node", 1, node),
ROW( CommunicationClosed, "node", 1, node),
ROW( CommunicationOpened, "node", 1, node),
ROW( ConnectedApiVersion, "node", 1, node),
ROW( ConnectedApiVersion, "version", 2, version),
/* CHECKPOINT */
ROW( GlobalCheckpointStarted, "gci", 1, gci),
ROW( GlobalCheckpointCompleted, "gci", 1, gci),
ROW( LocalCheckpointStarted, "lci", 1, lci),
ROW( LocalCheckpointStarted, "keep_gci", 2, keep_gci),
ROW( LocalCheckpointStarted, "restore_gci", 3, restore_gci),
ROW( LocalCheckpointCompleted, "lci", 1, lci),
ROW( LCPStoppedInCalcKeepGci, "data", 1, data),
ROW( LCPFragmentCompleted, "node", 1, node),
ROW( LCPFragmentCompleted, "table_id", 2, table_id),
ROW( LCPFragmentCompleted, "fragment_id", 3, fragment_id),
ROW( UndoLogBlocked, "acc_count", 1, acc_count),
ROW( UndoLogBlocked, "tup_count", 2, tup_count),
/* STARTUP */
ROW( NDBStartStarted, "version", 1, version),
ROW( NDBStartCompleted, "version", 1, version),
// ROW( STTORRYRecieved),
ROW( StartPhaseCompleted, "phase", 1, phase),
ROW( StartPhaseCompleted, "starttype", 2, starttype),
ROW( CM_REGCONF, "own_id", 1, own_id),
ROW( CM_REGCONF, "president_id", 2, president_id),
ROW( CM_REGCONF, "dynamic_id", 3, dynamic_id),
ROW( CM_REGREF, "own_id", 1, own_id),
ROW( CM_REGREF, "other_id", 2, other_id),
ROW( CM_REGREF, "cause", 3, cause),
ROW( FIND_NEIGHBOURS, "own_id", 1, own_id),
ROW( FIND_NEIGHBOURS, "left_id", 3, left_id),
ROW( FIND_NEIGHBOURS, "right_id", 3, right_id),
ROW( FIND_NEIGHBOURS, "dynamic_id", 4, dynamic_id),
ROW( NDBStopStarted, "stoptype", 1, stoptype),
// ROW( NDBStopAborted),
ROW( StartREDOLog, "node", 1, node),
ROW( StartREDOLog, "keep_gci", 2, keep_gci),
ROW( StartREDOLog, "completed_gci", 3, completed_gci),
ROW( StartREDOLog, "restorable_gci", 4, restorable_gci),
ROW( StartLog, "log_part", 1, log_part),
ROW( StartLog, "start_mb", 2, start_mb),
ROW( StartLog, "stop_mb", 3, stop_mb),
ROW( StartLog, "gci", 4, gci),
ROW( UNDORecordsExecuted, "block", 1, block),
ROW( UNDORecordsExecuted, "data1", 2, data1),
ROW( UNDORecordsExecuted, "data2", 3, data2),
ROW( UNDORecordsExecuted, "data3", 4, data3),
ROW( UNDORecordsExecuted, "data4", 5, data4),
ROW( UNDORecordsExecuted, "data5", 6, data5),
ROW( UNDORecordsExecuted, "data6", 7, data6),
ROW( UNDORecordsExecuted, "data7", 8, data7),
ROW( UNDORecordsExecuted, "data8", 9, data8),
ROW( UNDORecordsExecuted, "data9", 10, data9),
ROW( UNDORecordsExecuted, "data10", 11, data10),
/* NODERESTART */
// ROW( NR_CopyDict),
// ROW( NR_CopyDistr),
ROW( NR_CopyFragsStarted, "dest_node", 1, dest_node),
ROW( NR_CopyFragDone, "dest_node", 1, dest_node),
ROW( NR_CopyFragDone, "table_id", 2, table_id),
ROW( NR_CopyFragDone, "fragment_id", 3, fragment_id),
ROW( NR_CopyFragsCompleted, "dest_node", 1, dest_node),
ROW( NodeFailCompleted, "block", 1, block), /* 0 = all */
ROW( NodeFailCompleted, "failed_node", 2, failed_node),
ROW( NodeFailCompleted, "completing_node", 3, completing_node), /* 0 = all */
ROW( NODE_FAILREP, "failed_node", 1, failed_node),
ROW( NODE_FAILREP, "failure_state", 2, failure_state),
/* TODO */
// ROW( ArbitState),
/* TODO */
// ROW( ArbitResult),
// ROW( GCP_TakeoverStarted),
// ROW( GCP_TakeoverCompleted),
// ROW( LCP_TakeoverStarted),
ROW( LCP_TakeoverCompleted, "state", 1, state),
/* STATISTIC */
ROW( TransReportCounters, "trans_count", 1, trans_count),
ROW( TransReportCounters, "commit_count", 2, commit_count),
ROW( TransReportCounters, "read_count", 3, read_count),
ROW( TransReportCounters, "simple_read_count", 4, simple_read_count),
ROW( TransReportCounters, "write_count", 5, write_count),
ROW( TransReportCounters, "attrinfo_count", 6, attrinfo_count),
ROW( TransReportCounters, "conc_op_count", 7, conc_op_count),
ROW( TransReportCounters, "abort_count", 8, abort_count),
ROW( TransReportCounters, "scan_count", 9, scan_count),
ROW( TransReportCounters, "range_scan_count", 10, range_scan_count),
ROW( OperationReportCounters, "ops", 1, ops),
ROW( TableCreated, "table_id", 1, table_id),
ROW( JobStatistic, "mean_loop_count", 1, mean_loop_count),
ROW( SendBytesStatistic, "to_node", 1, to_node),
ROW( SendBytesStatistic, "mean_sent_bytes", 2, mean_sent_bytes),
ROW( ReceiveBytesStatistic, "from_node", 1, from_node),
ROW( ReceiveBytesStatistic, "mean_received_bytes", 2, mean_received_bytes),
ROW( MemoryUsage, "gth", 1, gth),
ROW( MemoryUsage, "page_size_kb", 2, page_size_kb),
ROW( MemoryUsage, "pages_used", 3, pages_used),
ROW( MemoryUsage, "pages_total", 4, pages_total),
ROW( MemoryUsage, "block", 5, block),
/* ERROR */
ROW( TransporterError, "to_node", 1, to_node),
ROW( TransporterError, "code", 2, code),
ROW( TransporterWarning, "to_node", 1, to_node),
ROW( TransporterWarning, "code", 2, code),
ROW( MissedHeartbeat, "node", 1, node),
ROW( MissedHeartbeat, "count", 2, count),
ROW( DeadDueToHeartbeat, "node", 1, node),
/* TODO */
// ROW( WarningEvent),
/* INFO */
ROW( SentHeartbeat, "node", 1, node),
ROW( CreateLogBytes, "node", 1, node),
/* TODO */
// ROW( InfoEvent),
// Backup
ROW_FN( BackupStarted, "starting_node", 1, starting_node, ref_to_node),
ROW( BackupStarted, "backup_id", 2, backup_id),
ROW_FN(BackupFailedToStart,"starting_node",1, starting_node, ref_to_node),
ROW( BackupFailedToStart, "error", 2, error),
ROW_FN( BackupCompleted, "starting_node", 1, starting_node, ref_to_node),
ROW( BackupCompleted, "backup_id", 2, backup_id),
ROW( BackupCompleted, "start_gci", 3, start_gci),
ROW( BackupCompleted, "stop_gci", 4, stop_gci),
ROW( BackupCompleted, "n_bytes", 5, n_bytes),
ROW( BackupCompleted, "n_records", 6, n_records),
ROW( BackupCompleted, "n_log_bytes", 7, n_log_bytes),
ROW( BackupCompleted, "n_log_records", 8, n_log_records),
ROW_FN( BackupAborted, "starting_node", 1, starting_node, ref_to_node),
ROW( BackupAborted, "backup_id", 2, backup_id),
ROW( BackupAborted, "error", 3, error),
{ NDB_LE_ILLEGAL_TYPE, 0, 0, 0, 0}
};
struct Ndb_logevent_header_row {
const char *token; // token to use for text transfer
int offset; // offset into struct ndb_logevent
int size;
};
#define ROW2(a,b) \
{ a, offsetof(struct ndb_logevent, b), \
sizeof(((struct ndb_logevent *)0)->b) }
struct Ndb_logevent_header_row ndb_logevent_header[]= {
ROW2( "type", type),
ROW2( "time", time),
ROW2( "source_nodeid", source_nodeid),
{ 0, 0, 0 }
};
static int
insert_row(const char * pair, Properties & p){
BaseString tmp(pair);
tmp.trim(" \t\n\r");
Vector<BaseString> split;
tmp.split(split, ":=", 2);
if(split.size() != 2)
return -1;
p.put(split[0].trim().c_str(), split[1].trim().c_str());
return 0;
}
static
int memcpy_atoi(void *dst, const char *str, int sz)
{
switch (sz)
{
case 1:
{
Int8 val= atoi(str);
memcpy(dst,&val,sz);
return 0;
}
case 2:
{
Int16 val= atoi(str);
memcpy(dst,&val,sz);
return 0;
}
case 4:
{
Int32 val= atoi(str);
memcpy(dst,&val,sz);
return 0;
}
case 8:
{
Int64 val= atoi(str);
memcpy(dst,&val,sz);
return 0;
}
default:
{
return -1;
}
}
}
extern "C"
int ndb_logevent_get_next(const NdbLogEventHandle h,
struct ndb_logevent *dst,
unsigned timeout_in_milliseconds)
{
SocketInputStream in(h->socket, timeout_in_milliseconds);
Properties p;
char buf[256];
/* header */
while (1) {
if (in.gets(buf,sizeof(buf)) == 0)
{
h->m_error= NDB_LEH_READ_ERROR;
return -1;
}
if ( buf[0] == 0 )
{
// timed out
return 0;
}
if ( strcmp("log event reply\n", buf) == 0 )
break;
ndbout_c("skipped: %s", buf);
}
/* read name-value pairs into properties object */
while (1)
{
if (in.gets(buf,sizeof(buf)) == 0)
{
h->m_error= NDB_LEH_READ_ERROR;
return -1;
}
if ( buf[0] == 0 )
{
// timed out
return 0;
}
if ( buf[0] == '\n' )
{
break;
}
if (insert_row(buf,p))
{
h->m_error= NDB_LEH_READ_ERROR;
return -1;
}
}
int i;
const char *val;
dst->type= (enum Ndb_logevent_type)-1;
/* fill in header info from p*/
for (i= 0; ndb_logevent_header[i].token; i++)
{
if ( p.get(ndb_logevent_header[i].token, &val) == 0 )
{
ndbout_c("missing: %s\n", ndb_logevent_header[i].token);
h->m_error= NDB_LEH_MISSING_EVENT_SPECIFIER;
return -1;
}
if ( memcpy_atoi((char *)dst+ndb_logevent_header[i].offset, val,
ndb_logevent_header[i].size) )
{
h->m_error= NDB_LEH_INTERNAL_ERROR;
return -1;
}
}
Uint32 level;
LogLevel::EventCategory category;
Logger::LoggerLevel severity;
EventLoggerBase::EventTextFunction text_fn;
/* fill in rest of header info event_lookup */
if (EventLoggerBase::event_lookup(dst->type,category,level,severity,text_fn))
{
ndbout_c("unknown type: %d\n", dst->type);
h->m_error= NDB_LEH_UNKNOWN_EVENT_TYPE;
return -1;
}
dst->category= (enum ndb_mgm_event_category)category;
dst->severity= (enum ndb_mgm_event_severity)severity;
dst->level= level;
/* fill in header info from p */
for (i= 0; ndb_logevent_body[i].token; i++)
{
if ( ndb_logevent_body[i].type != dst->type )
continue;
if ( p.get(ndb_logevent_body[i].token, &val) == 0 )
{
h->m_error= NDB_LEH_UNKNOWN_EVENT_VARIABLE;
return -1;
}
if ( memcpy_atoi((char *)dst+ndb_logevent_body[i].offset, val,
ndb_logevent_body[i].size) )
{
h->m_error= NDB_LEH_INTERNAL_ERROR;
return -1;
}
}
return 1;
}
extern "C"
int ndb_logevent_get_latest_error(const NdbLogEventHandle h)
{
return h->m_error;
}
extern "C"
const char *ndb_logevent_get_latest_error_msg(const NdbLogEventHandle h)
{
for (int i= 0; ndb_logevent_error_messages[i].msg; i++)
if (ndb_logevent_error_messages[i].code == h->m_error)
return ndb_logevent_error_messages[i].msg;
return "<unknown error msg>";
}
ndb/src/mgmapi/ndb_logevent.hpp 0 → 100644
View file @ 3f255881
/* Copyright (C) 2003 MySQL AB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
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.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
#ifndef NDB_LOGEVENT_HPP
#define NDB_LOGEVENT_HPP
#include <ndb_logevent.h>
struct Ndb_logevent_body_row {
enum Ndb_logevent_type type; // type
const char *token; // token to use for text transfer
int index; // index into theData array
int (*index_fn)(int); // conversion function on the data array[index]
int offset; // offset into struct ndb_logevent
int size; // offset into struct ndb_logevent
};
extern
struct Ndb_logevent_body_row ndb_logevent_body[];
#endif
ndb/src/mgmsrv/MgmtSrvr.hpp
View file @ 3f255881
...@@ -49,6 +49,7 @@ class Ndb_mgmd_event_service : public EventLoggerBase ...@@ -49,6 +49,7 @@ class Ndb_mgmd_event_service : public EventLoggerBase
public: public:
struct Event_listener : public EventLoggerBase { struct Event_listener : public EventLoggerBase {
NDB_SOCKET_TYPE m_socket; NDB_SOCKET_TYPE m_socket;
Uint32 m_parsable;
}; };
private: private:
......
ndb/src/mgmsrv/Services.cpp
View file @ 3f255881
...@@ -31,6 +31,7 @@ ...@@ -31,6 +31,7 @@
#include <mgmapi_configuration.hpp> #include <mgmapi_configuration.hpp>
#include <Vector.hpp> #include <Vector.hpp>
#include "Services.hpp" #include "Services.hpp"
#include "../mgmapi/ndb_logevent.hpp"
extern bool g_StopServer; extern bool g_StopServer;
...@@ -256,6 +257,7 @@ ParserRow<MgmApiSession> commands[] = { ...@@ -256,6 +257,7 @@ ParserRow<MgmApiSession> commands[] = {
MGM_CMD("listen event", &MgmApiSession::listen_event, ""), MGM_CMD("listen event", &MgmApiSession::listen_event, ""),
MGM_ARG("node", Int, Optional, "Node"), MGM_ARG("node", Int, Optional, "Node"),
MGM_ARG("parsable", Int, Optional, "Parsable"),
MGM_ARG("filter", String, Mandatory, "Event category"), MGM_ARG("filter", String, Mandatory, "Event category"),
MGM_CMD("purge stale sessions", &MgmApiSession::purge_stale_sessions, ""), MGM_CMD("purge stale sessions", &MgmApiSession::purge_stale_sessions, ""),
...@@ -1249,28 +1251,52 @@ Ndb_mgmd_event_service::log(int eventType, const Uint32* theData, NodeId nodeId) ...@@ -1249,28 +1251,52 @@ Ndb_mgmd_event_service::log(int eventType, const Uint32* theData, NodeId nodeId)
Uint32 threshold; Uint32 threshold;
LogLevel::EventCategory cat; LogLevel::EventCategory cat;
Logger::LoggerLevel severity; Logger::LoggerLevel severity;
EventLoggerBase::EventTextFunction textF;
int i; int i;
DBUG_ENTER("Ndb_mgmd_event_service::log"); DBUG_ENTER("Ndb_mgmd_event_service::log");
DBUG_PRINT("enter",("eventType=%d, nodeid=%d", eventType, nodeId)); DBUG_PRINT("enter",("eventType=%d, nodeid=%d", eventType, nodeId));
if (EventLoggerBase::event_lookup(eventType,cat,threshold,severity)) if (EventLoggerBase::event_lookup(eventType,cat,threshold,severity,textF))
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
char m_text[256]; char m_text[256];
EventLogger::getText(m_text, sizeof(m_text), eventType, theData, nodeId); EventLogger::getText(m_text, sizeof(m_text),
textF, theData, nodeId);
BaseString str("log event reply\n");
str.appfmt("type=%d\n", eventType);
str.appfmt("time=%d\n", 0);
str.appfmt("source_nodeid=%d\n", nodeId);
for (i= 0; ndb_logevent_body[i].token; i++)
{
if ( ndb_logevent_body[i].type != eventType)
continue;
int val= theData[ndb_logevent_body[i].index];
if (ndb_logevent_body[i].index_fn)
val= (*(ndb_logevent_body[i].index_fn))(val);
str.appfmt("%s=%d\n",ndb_logevent_body[i].token, val);
}
Vector<NDB_SOCKET_TYPE> copy; Vector<NDB_SOCKET_TYPE> copy;
m_clients.lock(); m_clients.lock();
for(i = m_clients.size() - 1; i >= 0; i--){ for(i = m_clients.size() - 1; i >= 0; i--){
if(threshold <= m_clients[i].m_logLevel.getLogLevel(cat)){ if(threshold <= m_clients[i].m_logLevel.getLogLevel(cat)){
if(m_clients[i].m_socket != NDB_INVALID_SOCKET && if(m_clients[i].m_socket != NDB_INVALID_SOCKET)
println_socket(m_clients[i].m_socket, {
MAX_WRITE_TIMEOUT, m_text) == -1){ int r;
if (m_clients[i].m_parsable)
r= println_socket(m_clients[i].m_socket,
MAX_WRITE_TIMEOUT, str.c_str());
else
r= println_socket(m_clients[i].m_socket,
MAX_WRITE_TIMEOUT, m_text);
if (r == -1) {
copy.push_back(m_clients[i].m_socket); copy.push_back(m_clients[i].m_socket);
m_clients.erase(i, false); m_clients.erase(i, false);
} }
} }
} }
}
m_clients.unlock(); m_clients.unlock();
for(i = 0; (unsigned)i < copy.size(); i++){ for(i = 0; (unsigned)i < copy.size(); i++){
...@@ -1395,15 +1421,17 @@ MgmApiSession::getConnectionParameter(Parser_t::Context &ctx, ...@@ -1395,15 +1421,17 @@ MgmApiSession::getConnectionParameter(Parser_t::Context &ctx,
void void
MgmApiSession::listen_event(Parser<MgmApiSession>::Context & ctx, MgmApiSession::listen_event(Parser<MgmApiSession>::Context & ctx,
Properties const & args) { Properties const & args) {
Uint32 parsable= 0;
BaseString node, param, value; BaseString node, param, value;
args.get("node", node); args.get("node", node);
args.get("filter", param); args.get("filter", param);
args.get("parsable", &parsable);
int result = 0; int result = 0;
BaseString msg; BaseString msg;
Ndb_mgmd_event_service::Event_listener le; Ndb_mgmd_event_service::Event_listener le;
le.m_parsable = parsable;
le.m_socket = m_socket; le.m_socket = m_socket;
Vector<BaseString> list; Vector<BaseString> list;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7