开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
EventLogger.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：33k
源码类别：

MySQL数据库

开发平台：

Visual C++

EventLogger.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #include <ndb_global.h>
  19. #include "EventLogger.hpp"
  21. #include <NdbConfig.h>
  22. #include <kernel/BlockNumbers.h>
  23. #include <signaldata/ArbitSignalData.hpp>
  24. #include <GrepEvent.hpp>
  25. #include <NodeState.hpp>
  26. #include <version.h>
  28. //
  29. // PUBLIC
  30. //
  31. EventLoggerBase::~EventLoggerBase()
  32. {
  33.   
  34. }
  36. /**
  37.  * This matrix defines which event should be printed when
  38.  *
  39.  * threshold - is in range [0-15]
  40.  * severity  - DEBUG to ALERT (Type of log message)
  41.  */
  42. const EventLoggerBase::EventRepLogLevelMatrix EventLoggerBase::matrix[] = {
  43.   // CONNECTION
  44.   { EventReport::Connected,           LogLevel::llConnection, 8, Logger::LL_INFO },
  45.   { EventReport::Disconnected,        LogLevel::llConnection, 8, Logger::LL_ALERT },
  46.   { EventReport::CommunicationClosed, LogLevel::llConnection, 8, Logger::LL_INFO },
  47.   { EventReport::CommunicationOpened, LogLevel::llConnection, 8, Logger::LL_INFO },
  48.   { EventReport::ConnectedApiVersion, LogLevel::llConnection, 8, Logger::LL_INFO },
  49.   // CHECKPOINT
  50.   { EventReport::GlobalCheckpointStarted, LogLevel::llCheckpoint,  9, Logger::LL_INFO },
  51.   { EventReport::GlobalCheckpointCompleted,LogLevel::llCheckpoint,10, Logger::LL_INFO },
  52.   { EventReport::LocalCheckpointStarted,  LogLevel::llCheckpoint,  7, Logger::LL_INFO },
  53.   { EventReport::LocalCheckpointCompleted,LogLevel::llCheckpoint,  8, Logger::LL_INFO },
  54.   { EventReport::LCPStoppedInCalcKeepGci, LogLevel::llCheckpoint,  0, Logger::LL_ALERT },
  55.   { EventReport::LCPFragmentCompleted,    LogLevel::llCheckpoint, 11, Logger::LL_INFO },
  56.   { EventReport::UndoLogBlocked,          LogLevel::llCheckpoint,  7, Logger::LL_INFO },
  58.   // STARTUP
  59.   { EventReport::NDBStartStarted,          LogLevel::llStartUp, 1, Logger::LL_INFO },
  60.   { EventReport::NDBStartCompleted,        LogLevel::llStartUp, 1, Logger::LL_INFO },
  61.   { EventReport::STTORRYRecieved,          LogLevel::llStartUp,15, Logger::LL_INFO },
  62.   { EventReport::StartPhaseCompleted,      LogLevel::llStartUp, 4, Logger::LL_INFO },
  63.   { EventReport::CM_REGCONF,               LogLevel::llStartUp, 3, Logger::LL_INFO },
  64.   { EventReport::CM_REGREF,                LogLevel::llStartUp, 8, Logger::LL_INFO },
  65.   { EventReport::FIND_NEIGHBOURS,          LogLevel::llStartUp, 8, Logger::LL_INFO },
  66.   { EventReport::NDBStopStarted,           LogLevel::llStartUp, 1, Logger::LL_INFO },
  67.   { EventReport::NDBStopAborted,           LogLevel::llStartUp, 1, Logger::LL_INFO },
  68.   { EventReport::StartREDOLog,             LogLevel::llStartUp, 10, Logger::LL_INFO },
  69.   { EventReport::StartLog,                 LogLevel::llStartUp, 10, Logger::LL_INFO },
  70.   { EventReport::UNDORecordsExecuted,      LogLevel::llStartUp, 15, Logger::LL_INFO },
  71.   
  72.   // NODERESTART
  73.   { EventReport::NR_CopyDict,            LogLevel::llNodeRestart,  8, Logger::LL_INFO },
  74.   { EventReport::NR_CopyDistr,           LogLevel::llNodeRestart,  8, Logger::LL_INFO },
  75.   { EventReport::NR_CopyFragsStarted,    LogLevel::llNodeRestart,  8, Logger::LL_INFO },
  76.   { EventReport::NR_CopyFragDone,        LogLevel::llNodeRestart, 10, Logger::LL_INFO },
  77.   { EventReport::NR_CopyFragsCompleted,  LogLevel::llNodeRestart,  8, Logger::LL_INFO },
  79.   { EventReport::NodeFailCompleted,      LogLevel::llNodeRestart,  8, Logger::LL_ALERT},
  80.   { EventReport::NODE_FAILREP,           LogLevel::llNodeRestart,  8, Logger::LL_ALERT},
  81.   { EventReport::ArbitState,  LogLevel::llNodeRestart,  6, Logger::LL_INFO },
  82.   { EventReport::ArbitResult,  LogLevel::llNodeRestart,  2, Logger::LL_ALERT},
  83.   { EventReport::GCP_TakeoverStarted,    LogLevel::llNodeRestart,  7, Logger::LL_INFO },
  84.   { EventReport::GCP_TakeoverCompleted,  LogLevel::llNodeRestart,  7, Logger::LL_INFO },
  85.   { EventReport::LCP_TakeoverStarted,    LogLevel::llNodeRestart,  7, Logger::LL_INFO },
  86.   { EventReport::LCP_TakeoverCompleted,  LogLevel::llNodeRestart,  7, Logger::LL_INFO },
  88.   // STATISTIC
  89.   { EventReport::TransReportCounters,     LogLevel::llStatistic, 8, Logger::LL_INFO },
  90.   { EventReport::OperationReportCounters, LogLevel::llStatistic, 8, Logger::LL_INFO }, 
  91.   { EventReport::TableCreated,            LogLevel::llStatistic, 7, Logger::LL_INFO },
  92.   { EventReport::JobStatistic,            LogLevel::llStatistic, 9, Logger::LL_INFO },
  93.   { EventReport::SendBytesStatistic,      LogLevel::llStatistic, 9, Logger::LL_INFO },
  94.   { EventReport::ReceiveBytesStatistic,   LogLevel::llStatistic, 9, Logger::LL_INFO },
  95.   { EventReport::MemoryUsage,             LogLevel::llStatistic, 5, Logger::LL_INFO },
  97.   // ERROR
  98.   { EventReport::TransporterError,   LogLevel::llError, 2, Logger::LL_ERROR   },
  99.   { EventReport::TransporterWarning, LogLevel::llError, 8, Logger::LL_WARNING },
  100.   { EventReport::MissedHeartbeat,    LogLevel::llError, 8, Logger::LL_WARNING },
  101.   { EventReport::DeadDueToHeartbeat, LogLevel::llError, 8, Logger::LL_ALERT   },
  102.   { EventReport::WarningEvent,       LogLevel::llError, 2, Logger::LL_WARNING },
  103.   // INFO
  104.   { EventReport::SentHeartbeat,     LogLevel::llInfo, 12, Logger::LL_INFO },
  105.   { EventReport::CreateLogBytes,    LogLevel::llInfo, 11, Logger::LL_INFO },
  106.   { EventReport::InfoEvent,         LogLevel::llInfo,  2, Logger::LL_INFO },
  108.   //Single User
  109.   { EventReport::SingleUser,  LogLevel::llInfo, 7, Logger::LL_INFO},
  111.   // Backup
  112.   { EventReport::BackupStarted, LogLevel::llBackup, 7, Logger::LL_INFO },
  113.   { EventReport::BackupCompleted, LogLevel::llBackup, 7, Logger::LL_INFO },
  114.   { EventReport::BackupFailedToStart, LogLevel::llBackup, 7, Logger::LL_ALERT},
  115.   { EventReport::BackupAborted, LogLevel::llBackup, 7, Logger::LL_ALERT }
  116. };
  118. const Uint32 EventLoggerBase::matrixSize = sizeof(EventLoggerBase::matrix)/
  119.                                        sizeof(EventRepLogLevelMatrix);
  121. const char*
  122. EventLogger::getText(char * m_text, size_t m_text_len, 
  123.      int type,
  124.      const Uint32* theData, NodeId nodeId)
  125. {
  126.   // TODO: Change the switch implementation...
  127.   char theNodeId[32];
  128.   if (nodeId != 0){
  129.     BaseString::snprintf(theNodeId, 32, "Node %u: ", nodeId);
  130.   } else {
  131.     theNodeId[0] = 0;
  132.   }
  134.   EventReport::EventType eventType = (EventReport::EventType)type;
  135.   switch (eventType){
  136.   case EventReport::Connected:
  137.     BaseString::snprintf(m_text, m_text_len, 
  138.        "%sNode %u Connected",
  139.        theNodeId,
  140.        theData[1]);
  141.   break;
  142.   case EventReport::ConnectedApiVersion:
  143.     BaseString::snprintf(m_text, m_text_len, 
  144.        "%sNode %u: API version %d.%d.%d",
  145.        theNodeId,
  146.        theData[1],
  147.        getMajor(theData[2]),
  148.        getMinor(theData[2]),
  149.        getBuild(theData[2]));
  150.   break;
  151.   case EventReport::Disconnected:
  152.     BaseString::snprintf(m_text, m_text_len, 
  153.        "%sNode %u Disconnected", 
  154.        theNodeId,
  155.        theData[1]);
  156.   break;
  157.   case EventReport::CommunicationClosed:
  158.     //-----------------------------------------------------------------------
  159.     // REPORT communication to node closed.
  160.     //-----------------------------------------------------------------------
  161.     BaseString::snprintf(m_text, m_text_len, 
  162.        "%sCommunication to Node %u closed", 
  163.        theNodeId,
  164.        theData[1]);
  165.   break;
  166.   case EventReport::CommunicationOpened:
  167.     //-----------------------------------------------------------------------
  168.     // REPORT communication to node opened.
  169.     //-----------------------------------------------------------------------
  170.     BaseString::snprintf(m_text, m_text_len, 
  171.        "%sCommunication to Node %u opened", 
  172.        theNodeId,
  173.        theData[1]);
  174.   break;
  175.   case EventReport::NDBStartStarted:
  176.     //-----------------------------------------------------------------------
  177.     // Start of NDB has been initiated.
  178.     //-----------------------------------------------------------------------
  179.     BaseString::snprintf(m_text, m_text_len, 
  180.        "%sStart initiated (version %d.%d.%d)", 
  181.        theNodeId ,
  182.        getMajor(theData[1]),
  183.        getMinor(theData[1]),
  184.        getBuild(theData[1]));
  185.   break;
  186.   case EventReport::NDBStopStarted:
  187.     BaseString::snprintf(m_text, m_text_len,
  188.        "%s%s shutdown initiated", 
  189.        theNodeId, 
  190.        (theData[1] == 1 ? "Cluster" : "Node"));
  191.   break;
  192.   case EventReport::NDBStopAborted:
  193.     BaseString::snprintf(m_text, m_text_len,
  194.        "%sNode shutdown aborted",
  195.        theNodeId);
  196.   break;
  197.   case EventReport::NDBStartCompleted:
  198.     //-----------------------------------------------------------------------
  199.     // Start of NDB has been completed.
  200.     //-----------------------------------------------------------------------
  201.     BaseString::snprintf(m_text, m_text_len, 
  202.        "%sStarted (version %d.%d.%d)", 
  203.        theNodeId ,
  204.        getMajor(theData[1]),
  205.        getMinor(theData[1]),
  206.        getBuild(theData[1]));
  208.   break;
  209.   case EventReport::STTORRYRecieved:
  210.     //-----------------------------------------------------------------------
  211.     // STTORRY recevied after restart finished.
  212.     //-----------------------------------------------------------------------
  213.     BaseString::snprintf(m_text, m_text_len, 
  214.        "%sSTTORRY received after restart finished",
  215.        theNodeId);
  216.   break;
  217.   case EventReport::StartPhaseCompleted:{
  218.     //-----------------------------------------------------------------------
  219.     // REPORT Start phase completed.
  220.     //-----------------------------------------------------------------------
  221.     const char * type = "<Unknown>";
  222.     switch((NodeState::StartType)theData[2]){
  223.     case NodeState::ST_INITIAL_START:
  224.       type = "(initial start)";
  225.       break;
  226.     case NodeState::ST_SYSTEM_RESTART:
  227.       type = "(system restart)";
  228.       break;
  229.     case NodeState::ST_NODE_RESTART:
  230.       type = "(node restart)";
  231.       break;
  232.     case NodeState::ST_INITIAL_NODE_RESTART:
  233.       type = "(initial node restart)";
  234.       break;
  235.     case NodeState::ST_ILLEGAL_TYPE:
  236.       type = "";
  237.       break;
  238.     default:{
  239.       BaseString::snprintf(m_text, m_text_len, 
  240.  "%sStart phase %u completed (unknown = %d)", 
  241.  theNodeId,
  242.  theData[1],
  243.  theData[2]);
  244.       return m_text;
  245.     }
  246.     }
  247.     BaseString::snprintf(m_text, m_text_len, 
  248.        "%sStart phase %u completed %s", 
  249.        theNodeId,
  250.        theData[1],
  251.        type);
  252.     return m_text;
  253.     break;
  254.   }
  255.   case EventReport::CM_REGCONF:
  256.     BaseString::snprintf(m_text, m_text_len, 
  257.        "%sCM_REGCONF president = %u, own Node = %u, our dynamic id = %u"
  258.        , 
  259.        theNodeId,
  260.        theData[2], 
  261.        theData[1],
  262.        theData[3]);
  263.   break;
  264.   case EventReport::CM_REGREF:
  265.   {
  266.     const char* line = "";
  267.     switch (theData[3]) {
  268.     case 0:
  269.       line = "Busy";
  270.       break;
  271.     case 1:
  272.       line = "Election with wait = false";
  273.       break;
  274.     case 2:
  275.       line = "Election with wait = false";
  276.       break;
  277.     case 3:
  278.       line = "Not president";
  279.       break;
  280.     case 4:
  281.       line = "Election without selecting new candidate";
  282.       break;
  283.     default:
  284.       line = "No such cause";
  285.       break;
  286.     }//switch
  288.     BaseString::snprintf(m_text, m_text_len, 
  289.        "%sCM_REGREF from Node %u to our Node %u. Cause = %s", 
  290.        theNodeId,
  291.        theData[2], 
  292.        theData[1], 
  293.        line);
  294.   }
  295.   break;
  296.   case EventReport::FIND_NEIGHBOURS:
  297.     //-----------------------------------------------------------------------
  298.     // REPORT Node Restart copied a fragment.
  299.     //-----------------------------------------------------------------------
  300.     BaseString::snprintf(m_text, 
  301.        m_text_len, 
  302.        "%sWe are Node %u with dynamic ID %u, our left neighbour "
  303.        "is Node %u, our right is Node %u", 
  304.        theNodeId,
  305.        theData[1], 
  306.        theData[4], 
  307.        theData[2], 
  308.        theData[3]);
  309.   break;
  310.   case EventReport::NodeFailCompleted:
  311.     //-----------------------------------------------------------------------
  312.     // REPORT Node failure phase completed.
  313.     //-----------------------------------------------------------------------
  314.     if (theData[1] == 0)
  315.     {
  316.       if (theData[3] != 0) {
  317.         BaseString::snprintf(m_text, m_text_len, 
  318.  "%sNode %u completed failure of Node %u", 
  319.  theNodeId,
  320.  theData[3], 
  321.  theData[2]);
  322.       } else {
  323.         BaseString::snprintf(m_text, m_text_len, 
  324.  "%sAll nodes completed failure of Node %u", 
  325.  theNodeId,
  326.  theData[2]);
  327.       }//if      
  328.     } else {
  329.       const char* line = "";
  330.       if (theData[1] == DBTC){
  331. line = "DBTC";
  332.       }else if (theData[1] == DBDICT){
  333. line = "DBDICT";
  334.       }else if (theData[1] == DBDIH){
  335. line = "DBDIH";
  336.       }else if (theData[1] == DBLQH){
  337. line = "DBLQH";
  338.       }
  339.       
  340.       BaseString::snprintf(m_text, m_text_len, 
  341.  "%sNode failure of %u %s completed", 
  342.  theNodeId,
  343.  theData[2], 
  344.  line);
  345.     }
  346.     break;
  347.   case EventReport::NODE_FAILREP:
  348.     BaseString::snprintf(m_text, 
  349.        m_text_len, 
  350.        "%sNode %u has failed. The Node state at failure "
  351.        "was %u", 
  352.        theNodeId,
  353.        theData[1], 
  354.        theData[2]); 
  356.   break;
  357.   case EventReport::ArbitState:
  358.     //-----------------------------------------------------------------------
  359.     // REPORT arbitrator found or lost.
  360.     //-----------------------------------------------------------------------
  361.     { const ArbitSignalData* sd = (ArbitSignalData*)theData;
  362.       char ticketText[ArbitTicket::TextLength + 1];
  363.       char errText[ArbitCode::ErrTextLength + 1];
  364.       const unsigned code = sd->code & 0xFFFF;
  365.       const unsigned state = sd->code >> 16;
  366.       switch (code) {
  367.       case ArbitCode::ThreadStart:
  368.         BaseString::snprintf(m_text, m_text_len,
  369.           "%sPresident restarts arbitration thread [state=%u]",
  370.           theNodeId, state);
  371.         break;
  372.       case ArbitCode::PrepPart2:
  373. sd->ticket.getText(ticketText, sizeof(ticketText));
  374. BaseString::snprintf(m_text, m_text_len,
  375.   "%sPrepare arbitrator node %u [ticket=%s]",
  376.   theNodeId, sd->node, ticketText);
  377. break;
  378.       case ArbitCode::PrepAtrun:
  379. sd->ticket.getText(ticketText, sizeof(ticketText));
  380. BaseString::snprintf(m_text, m_text_len,
  381.   "%sReceive arbitrator node %u [ticket=%s]",
  382.   theNodeId, sd->node, ticketText);
  383. break;
  384.       case ArbitCode::ApiStart:
  385. sd->ticket.getText(ticketText, sizeof(ticketText));
  386. BaseString::snprintf(m_text, m_text_len,
  387.   "%sStarted arbitrator node %u [ticket=%s]",
  388.   theNodeId, sd->node, ticketText);
  389. break;
  390.       case ArbitCode::ApiFail:
  391. BaseString::snprintf(m_text, m_text_len,
  392.   "%sLost arbitrator node %u - process failure [state=%u]",
  393.   theNodeId, sd->node, state);
  394. break;
  395.       case ArbitCode::ApiExit:
  396. BaseString::snprintf(m_text, m_text_len,
  397.   "%sLost arbitrator node %u - process exit [state=%u]",
  398.   theNodeId, sd->node, state);
  399. break;
  400.       default:
  401. ArbitCode::getErrText(code, errText, sizeof(errText));
  402. BaseString::snprintf(m_text, m_text_len,
  403.   "%sLost arbitrator node %u - %s [state=%u]",
  404.   theNodeId, sd->node, errText, state);
  405. break;
  406.       }
  407.     }
  408.     break;
  409.   case EventReport::ArbitResult:
  410.     //-----------------------------------------------------------------------
  411.     // REPORT arbitration result (the failures may not reach us).
  412.     //-----------------------------------------------------------------------
  413.     { const ArbitSignalData* sd = (ArbitSignalData*)theData;
  414.       char errText[ArbitCode::ErrTextLength + 1];
  415.       const unsigned code = sd->code & 0xFFFF;
  416.       const unsigned state = sd->code >> 16;
  417.       switch (code) {
  418.       case ArbitCode::LoseNodes:
  419. BaseString::snprintf(m_text, m_text_len,
  420.   "%sArbitration check lost - less than 1/2 nodes left",
  421.   theNodeId);
  422. break;
  423.       case ArbitCode::WinNodes:
  424. BaseString::snprintf(m_text, m_text_len,
  425.   "%sArbitration check won - all node groups and more than 1/2 nodes left",
  426.   theNodeId);
  427. break;
  428.       case ArbitCode::WinGroups:
  429. BaseString::snprintf(m_text, m_text_len,
  430.   "%sArbitration check won - node group majority",
  431.   theNodeId);
  432. break;
  433.       case ArbitCode::LoseGroups:
  434. BaseString::snprintf(m_text, m_text_len,
  435.   "%sArbitration check lost - missing node group",
  436.   theNodeId);
  437. break;
  438.       case ArbitCode::Partitioning:
  439. BaseString::snprintf(m_text, m_text_len,
  440.   "%sNetwork partitioning - arbitration required",
  441.   theNodeId);
  442. break;
  443.       case ArbitCode::WinChoose:
  444. BaseString::snprintf(m_text, m_text_len,
  445.   "%sArbitration won - positive reply from node %u",
  446.   theNodeId, sd->node);
  447. break;
  448.       case ArbitCode::LoseChoose:
  449. BaseString::snprintf(m_text, m_text_len,
  450.   "%sArbitration lost - negative reply from node %u",
  451.   theNodeId, sd->node);
  452. break;
  453.       case ArbitCode::LoseNorun:
  454. BaseString::snprintf(m_text, m_text_len,
  455.   "%sNetwork partitioning - no arbitrator available",
  456.   theNodeId);
  457. break;
  458.       case ArbitCode::LoseNocfg:
  459. BaseString::snprintf(m_text, m_text_len,
  460.   "%sNetwork partitioning - no arbitrator configured",
  461.   theNodeId);
  462. break;
  463.       default:
  464. ArbitCode::getErrText(code, errText, sizeof(errText));
  465. BaseString::snprintf(m_text, m_text_len,
  466.   "%sArbitration failure - %s [state=%u]",
  467.   theNodeId, errText, state);
  468. break;
  469.       }
  470.     }
  471.     break;
  472.   case EventReport::GlobalCheckpointStarted:
  473.     //-----------------------------------------------------------------------
  474.     // This event reports that a global checkpoint has been started and this
  475.     // node is the master of this global checkpoint.
  476.     //-----------------------------------------------------------------------
  477.     BaseString::snprintf(m_text, 
  478.        m_text_len, 
  479.        "%sGlobal checkpoint %u started", 
  480.        theNodeId,
  481.        theData[1]);
  482.     break;
  483.   case EventReport::GlobalCheckpointCompleted:
  484.     //-----------------------------------------------------------------------
  485.     // This event reports that a global checkpoint has been completed on this
  486.     // node and the node is the master of this global checkpoint.
  487.     //-----------------------------------------------------------------------
  488.     BaseString::snprintf(m_text, m_text_len, 
  489.        "%sGlobal checkpoint %u completed", 
  490.        theNodeId,
  491.        theData[1]);
  492.     break;
  493.   case EventReport::LocalCheckpointStarted:
  494.     //-----------------------------------------------------------------------
  495.     // This event reports that a local checkpoint has been started and this
  496.     // node is the master of this local checkpoint.
  497.     //-----------------------------------------------------------------------
  498.     BaseString::snprintf(m_text, 
  499.        m_text_len, 
  500.        "%sLocal checkpoint %u started. "
  501.        "Keep GCI = %u oldest restorable GCI = %u", 
  502.        theNodeId,
  503.        theData[1], 
  504.        theData[2], 
  505.        theData[3]);
  506.     break;
  507.   case EventReport::LocalCheckpointCompleted:
  508.     //-----------------------------------------------------------------------
  509.     // This event reports that a local checkpoint has been completed on this
  510.     // node and the node is the master of this local checkpoint.
  511.     //-----------------------------------------------------------------------
  512.     BaseString::snprintf(m_text, 
  513.        m_text_len, 
  514.        "%sLocal checkpoint %u completed", 
  515.        theNodeId,
  516.        theData[1]);
  517.     break;
  518.   case EventReport::TableCreated:
  519.     //-----------------------------------------------------------------------
  520.     // This event reports that a table has been created.
  521.     //-----------------------------------------------------------------------
  522.     BaseString::snprintf(m_text, m_text_len, 
  523.        "%sTable with ID =  %u created", 
  524.        theNodeId,
  525.        theData[1]);
  526.     break;
  527.   case EventReport::LCPStoppedInCalcKeepGci:
  528.     if (theData[1] == 0)
  529.       BaseString::snprintf(m_text, m_text_len, 
  530.  "%sLocal Checkpoint stopped in CALCULATED_KEEP_GCI",
  531.  theNodeId);
  532.     break;
  533.   case EventReport::NR_CopyDict:
  534.     //-----------------------------------------------------------------------
  535.     // REPORT Node Restart completed copy of dictionary information.
  536.     //-----------------------------------------------------------------------
  537.     BaseString::snprintf(m_text, 
  538.        m_text_len, 
  539.        "%sNode restart completed copy of dictionary information",
  540.        theNodeId);
  541.     break;
  542.   case EventReport::NR_CopyDistr:
  543.     //-----------------------------------------------------------------------
  544.     // REPORT Node Restart completed copy of distribution information.
  545.     //-----------------------------------------------------------------------
  546.     BaseString::snprintf(m_text, 
  547.        m_text_len, 
  548.        "%sNode restart completed copy of distribution information",
  549.        theNodeId);
  550.     break;
  551.   case EventReport::NR_CopyFragsStarted:
  552.     //-----------------------------------------------------------------------
  553.     // REPORT Node Restart is starting to copy the fragments.
  554.     //-----------------------------------------------------------------------
  555.     BaseString::snprintf(m_text, 
  556.        m_text_len, 
  557.        "%sNode restart starting to copy the fragments "
  558.        "to Node %u", 
  559.        theNodeId,
  560.        theData[1]);
  561.     break;
  562.   case EventReport::NR_CopyFragDone:
  563.     //-----------------------------------------------------------------------
  564.     // REPORT Node Restart copied a fragment.
  565.     //-----------------------------------------------------------------------
  566.     BaseString::snprintf(m_text, 
  567.        m_text_len, 
  568.        "%sTable ID = %u, fragment ID = %u have been copied "
  569.        "to Node %u", 
  570.        theNodeId,
  571.        theData[2], 
  572.        theData[3], 
  573.        theData[1]);
  574.   break;
  575.   case EventReport::NR_CopyFragsCompleted:
  576.     BaseString::snprintf(m_text, 
  577.        m_text_len, 
  578.        "%sNode restart completed copying the fragments "
  579.        "to Node %u", 
  580.        theNodeId,
  581.        theData[1]);
  582.     break;
  583.   case EventReport::LCPFragmentCompleted:
  584.     BaseString::snprintf(m_text, 
  585.        m_text_len, 
  586.        "%sTable ID = %u, fragment ID = %u has completed LCP "
  587.        "on Node %u maxGciStarted: %d maxGciCompleted: %d", 
  588.        theNodeId,
  589.        theData[2], 
  590.        theData[3], 
  591.        theData[1],
  592.        theData[4],
  593.        theData[5]);
  594.     break;
  595.   case EventReport::TransReportCounters:
  596.     // -------------------------------------------------------------------  
  597.     // Report information about transaction activity once per 10 seconds.
  598.     // ------------------------------------------------------------------- 
  599.     BaseString::snprintf(m_text, 
  600.        m_text_len, 
  601.        "%sTrans. Count = %u, Commit Count = %u, "
  602.        "Read Count = %u, Simple Read Count = %u,n"
  603.        "Write Count = %u, AttrInfo Count = %u, "
  604.        "Concurrent Operations = %u, Abort Count = %un"
  605.        " Scans: %u Range scans: %u", 
  606.        theNodeId,
  607.        theData[1], 
  608.        theData[2], 
  609.        theData[3], 
  610.        theData[4],
  611.        theData[5], 
  612.        theData[6], 
  613.        theData[7], 
  614.        theData[8],
  615.        theData[9],
  616.        theData[10]);
  617.     break;
  618.   case EventReport::OperationReportCounters:
  619.     BaseString::snprintf(m_text, m_text_len,
  620.        "%sOperations=%u",
  621.        theNodeId, 
  622.        theData[1]);
  623.     break;
  624.   case EventReport::UndoLogBlocked:
  625.     //-----------------------------------------------------------------------
  626.     // REPORT Undo Logging blocked due to buffer near to overflow.
  627.     //-----------------------------------------------------------------------
  628.     BaseString::snprintf(m_text, 
  629.        m_text_len, 
  630.        "%sACC Blocked %u and TUP Blocked %u times last second",
  631.        theNodeId,
  632.        theData[1],
  633.        theData[2]);
  634.   break;
  635.   case EventReport::TransporterError:
  636.   case EventReport::TransporterWarning:
  637.     BaseString::snprintf(m_text, 
  638.        m_text_len, 
  639.        "%sTransporter to node %d reported error 0x%x",
  640.        theNodeId,
  641.        theData[1],
  642.        theData[2]);
  643.   break;
  644.   case EventReport::MissedHeartbeat:
  645.     //-----------------------------------------------------------------------
  646.     // REPORT Undo Logging blocked due to buffer near to overflow.
  647.     //-----------------------------------------------------------------------
  648.     BaseString::snprintf(m_text, 
  649.        m_text_len, 
  650.        "%sNode %d missed heartbeat %d",
  651.        theNodeId,
  652.        theData[1],
  653.        theData[2]);
  654.   break;
  655.   case EventReport::DeadDueToHeartbeat:
  656.     //-----------------------------------------------------------------------
  657.     // REPORT Undo Logging blocked due to buffer near to overflow.
  658.     //-----------------------------------------------------------------------
  659.     BaseString::snprintf(m_text, 
  660.        m_text_len, 
  661.        "%sNode %d declared dead due to missed heartbeat",
  662.        theNodeId,
  663.        theData[1]);
  664.   break;
  665.   case EventReport::JobStatistic:
  666.     BaseString::snprintf(m_text, 
  667.        m_text_len, 
  668.        "%sMean loop Counter in doJob last 8192 times = %u",
  669.        theNodeId,
  670.        theData[1]);
  671.     break;
  672.   case EventReport::SendBytesStatistic:
  673.     BaseString::snprintf(m_text, 
  674.        m_text_len, 
  675.        "%sMean send size to Node = %d last 4096 sends = %u bytes",
  676.        theNodeId,
  677.        theData[1],
  678.        theData[2]);
  679.     break;
  680.   case EventReport::ReceiveBytesStatistic:
  681.     BaseString::snprintf(m_text, 
  682.        m_text_len, 
  683.        "%sMean receive size to Node = %d last 4096 sends = %u bytes",
  684.        theNodeId,
  685.        theData[1],
  686.        theData[2]);
  687.   break;
  688.   case EventReport::SentHeartbeat:
  689.     BaseString::snprintf(m_text, 
  690.        m_text_len, 
  691.        "%sNode Sent Heartbeat to node = %d",
  692.        theNodeId,
  693.        theData[1]);
  694.   break;
  695.   case EventReport::CreateLogBytes:
  696.     BaseString::snprintf(m_text, 
  697.        m_text_len, 
  698.        "%sLog part %u, log file %u, MB %u",
  699.        theNodeId,
  700.        theData[1],
  701.        theData[2],
  702.        theData[3]);
  703.   break;
  704.   case EventReport::StartLog:
  705.     BaseString::snprintf(m_text, 
  706.        m_text_len, 
  707.        "%sLog part %u, start MB %u, stop MB %u, last GCI, log exec %u",
  708.        theNodeId,
  709.        theData[1],
  710.        theData[2],
  711.        theData[3],
  712.        theData[4]);
  713.   break;
  714.   case EventReport::StartREDOLog:
  715.     BaseString::snprintf(m_text, 
  716.        m_text_len, 
  717.        "%sNode: %d StartLog: [GCI Keep: %d LastCompleted: %d NewestRestorable: %d]",
  718.        theNodeId,
  719.        theData[1],
  720.        theData[2],
  721.        theData[3],
  722.        theData[4]);
  723.   break;
  724.   case EventReport::UNDORecordsExecuted:{
  725.     const char* line = "";
  726.     if (theData[1] == DBTUP){
  727.       line = "DBTUP";
  728.     }else if (theData[1] == DBACC){
  729.       line = "DBACC";
  730.     }
  731.     
  732.     BaseString::snprintf(m_text, 
  733.        m_text_len, 
  734.        "%s UNDO %s %d [%d %d %d %d %d %d %d %d %d]",
  735.        theNodeId,
  736.        line,
  737.        theData[2],
  738.        theData[3],
  739.        theData[4],
  740.        theData[5],
  741.        theData[6],
  742.        theData[7],
  743.        theData[8],
  744.        theData[9],
  745.        theData[10],
  746.        theData[11]);
  747.   }
  748.     break;
  749.   case EventReport::InfoEvent:
  750.     BaseString::snprintf(m_text, 
  751.        m_text_len, 
  752.        "%s%s",
  753.        theNodeId,
  754.        (char *)&theData[1]);
  755.   break;
  756.   case EventReport::WarningEvent:
  757.     BaseString::snprintf(m_text, 
  758.        m_text_len, 
  759.        "%s%s",
  760.        theNodeId,
  761.        (char *)&theData[1]);
  762.   break;
  763.   case EventReport::GCP_TakeoverStarted:
  764.     BaseString::snprintf(m_text,
  765.        m_text_len,
  766.        "%sGCP Take over started", theNodeId);
  767.   break;
  768.   case EventReport::GCP_TakeoverCompleted:
  769.     BaseString::snprintf(m_text,
  770.        m_text_len,
  771.        "%sGCP Take over completed", theNodeId);
  772.   break;
  773.   case EventReport::LCP_TakeoverStarted:
  774.     BaseString::snprintf(m_text,
  775.        m_text_len,
  776.        "%sLCP Take over started", theNodeId);
  777.   break;
  778.   case EventReport::LCP_TakeoverCompleted:
  779.     BaseString::snprintf(m_text,
  780.        m_text_len,
  781.        "%sLCP Take over completed (state = %d)", 
  782.        theNodeId, theData[1]);
  783.   break;
  784.   case EventReport::MemoryUsage:{
  785.     const int gth = theData[1];
  786.     const int size = theData[2];
  787.     const int used = theData[3];
  788.     const int total = theData[4];
  789.     const int block = theData[5];
  790.     const int percent = (used*100)/total;
  791.     
  792.     BaseString::snprintf(m_text, m_text_len,
  793.        "%s%s usage %s %d%s(%d %dK pages of total %d)",
  794.        theNodeId,
  795.        (block==DBACC ? "Index" : (block == DBTUP ?"Data":"<unknown>")),
  796.        (gth == 0 ? "is" : (gth > 0 ? "increased to" : "decreased to")),
  797.        percent, "%",
  798.        used, size/1024, total
  799.        );
  800.     break;
  801.   }
  802.   case EventReport::SingleUser : 
  803.   {   
  804.     switch (theData[1])
  805.     {
  806.     case 0:
  807.       BaseString::snprintf(m_text, m_text_len, 
  808.    "%sEntering single user mode", theNodeId);
  809.       break;
  810.     case 1:
  811.       BaseString::snprintf(m_text, m_text_len, 
  812.    "%sEntered single user mode %d", theNodeId, theData[2]);
  813.       break;
  814.     case 2:
  815.       BaseString::snprintf(m_text, m_text_len, 
  816.    "%sExiting single user mode", theNodeId);
  817.       break;
  818.     default:
  819.       BaseString::snprintf(m_text, m_text_len, 
  820.    "%sUnknown single user report %d", theNodeId, theData[1]);
  821.       break;
  822.     }
  823.     break;
  824.   }      
  825.   case EventReport::BackupStarted:
  826.     BaseString::snprintf(m_text,
  827.        m_text_len,
  828.        "%sBackup %d started from node %d", 
  829.        theNodeId, theData[2], refToNode(theData[1]));
  830.   break;
  831.   case EventReport::BackupFailedToStart:
  832.     BaseString::snprintf(m_text,
  833.        m_text_len,
  834.        "%sBackup request from %d failed to start. Error: %d", 
  835.        theNodeId, refToNode(theData[1]), theData[2]);
  836.   break;
  837.   case EventReport::BackupCompleted:
  838.     BaseString::snprintf(m_text,
  839.        m_text_len,
  840.        "%sBackup %u started from node %u completedn" 
  841.        " StartGCP: %u StopGCP: %un"
  842.        " #Records: %u #LogRecords: %un"
  843.        " Data: %u bytes Log: %u bytes",
  844.        theNodeId, theData[2], refToNode(theData[1]),
  845.        theData[3], theData[4], theData[6], theData[8],
  846.        theData[5], theData[7]);
  847.   break;
  848.   case EventReport::BackupAborted:
  849.     BaseString::snprintf(m_text,
  850.        m_text_len,
  851.        "%sBackup %d started from %d has been aborted. Error: %d",
  852.        theNodeId, 
  853.        theData[2], 
  854.        refToNode(theData[1]), 
  855.        theData[3]);
  856.   break;
  857.   default:
  858.     BaseString::snprintf(m_text, 
  859.        m_text_len, 
  860.        "%sUnknown event: %d",
  861.        theNodeId,
  862.        theData[0]);
  863.   
  864.   }
  865.   return m_text;
  866. }
  868. EventLogger::EventLogger() : m_filterLevel(15)
  869. {
  870.   setCategory("EventLogger");
  871.   enable(Logger::LL_INFO, Logger::LL_ALERT); 
  872. }
  874. EventLogger::~EventLogger()
  875. {
  876. }
  878. bool
  879. EventLogger::open(const char* logFileName, int maxNoFiles, long maxFileSize, 
  880.   unsigned int maxLogEntries)
  881. {
  882.   return addHandler(new FileLogHandler(logFileName, maxNoFiles, maxFileSize, 
  883.        maxLogEntries));
  884. }
  886. void
  887. EventLogger::close()
  888. {
  889.   removeAllHandlers();
  890. }
  892. static NdbOut&
  893. operator<<(NdbOut& out, const LogLevel & ll)
  894. {
  895.   out << "[LogLevel: ";
  896.   for(size_t i = 0; i<LogLevel::LOGLEVEL_CATEGORIES; i++)
  897.     out << ll.getLogLevel((LogLevel::EventCategory)i) << " ";
  898.   out << "]";
  899.   return out;
  900. }
  902. int
  903. EventLoggerBase::event_lookup(int eventType,
  904.       LogLevel::EventCategory &cat,
  905.       Uint32 &threshold, 
  906.       Logger::LoggerLevel &severity)
  907. {
  908.   for(unsigned i = 0; i<EventLoggerBase::matrixSize; i++){
  909.     if(EventLoggerBase::matrix[i].eventType == eventType){
  910.       cat = EventLoggerBase::matrix[i].eventCategory;
  911.       threshold = EventLoggerBase::matrix[i].threshold;
  912.       severity = EventLoggerBase::matrix[i].severity;
  913.       return 0;
  914.     }
  915.   }
  916.   return 1;
  917. }
  919. void 
  920. EventLogger::log(int eventType, const Uint32* theData, NodeId nodeId,
  921.  const LogLevel* ll)
  922. {
  923.   Uint32 threshold = 0;
  924.   Logger::LoggerLevel severity = Logger::LL_WARNING;
  925.   LogLevel::EventCategory cat= LogLevel::llInvalid;
  927.   DBUG_ENTER("EventLogger::log");
  928.   DBUG_PRINT("enter",("eventType=%d, nodeid=%d", eventType, nodeId));
  930.   if (EventLoggerBase::event_lookup(eventType,cat,threshold,severity))
  931.     DBUG_VOID_RETURN;
  932.   
  933.   Uint32 set = ll?ll->getLogLevel(cat) : m_logLevel.getLogLevel(cat);
  934.   DBUG_PRINT("info",("threshold=%d, set=%d", threshold, set));
  935.   if (ll)
  936.     DBUG_PRINT("info",("m_logLevel.getLogLevel=%d", m_logLevel.getLogLevel(cat)));
  937.   if (threshold <= set){
  938.     switch (severity){
  939.     case Logger::LL_ALERT:
  940.       alert(EventLogger::getText(m_text, sizeof(m_text), 
  941.  eventType, theData, nodeId));
  942.       break;
  943.       
  944.     case Logger::LL_CRITICAL:
  945.       critical(EventLogger::getText(m_text, sizeof(m_text), 
  946.     eventType, theData, nodeId));
  947.       break;
  948.       
  949.     case Logger::LL_WARNING:
  950.       warning(EventLogger::getText(m_text, sizeof(m_text), 
  951.    eventType, theData, nodeId));
  952.       break;
  953.       
  954.     case Logger::LL_ERROR:
  955.       error(EventLogger::getText(m_text, sizeof(m_text), 
  956.  eventType, theData, nodeId));
  957.       break;
  958.       
  959.     case Logger::LL_INFO:
  960.       info(EventLogger::getText(m_text, sizeof(m_text), 
  961. eventType, theData, nodeId));
  962.       break;
  963.       
  964.     case Logger::LL_DEBUG:
  965.       debug(EventLogger::getText(m_text, sizeof(m_text), 
  966.  eventType, theData, nodeId));
  967.       break;
  968.       
  969.     default:
  970.       info(EventLogger::getText(m_text, sizeof(m_text), 
  971. eventType, theData, nodeId));
  972.       break;
  973.     }
  974.   } // if (..
  975.   DBUG_VOID_RETURN;
  976. }
  978. int
  979. EventLogger::getFilterLevel() const
  980. {
  981.   return m_filterLevel;
  982. }
  984. void 
  985. EventLogger::setFilterLevel(int filterLevel)
  986. {
  987.   m_filterLevel = filterLevel;
  988. }
  990. //
  991. // PRIVATE
  992. //