← Back to branch summary

~ubuntu-branches/ubuntu/trusty/mysql-5.6/trusty

« back to all changes in this revision

Viewing changes to storage/ndb/src/common/logger/Logger.cpp

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2014-02-12 11:54:27 UTC
  • Revision ID: package-import@ubuntu.com-20140212115427-oq6tfsqxl1wuwehi
Tags: upstream-5.6.15
Import upstream version 5.6.15

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/ndb/src/common/logger/Logger.cpp
 
1
/*
 
2
   Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
 
3
 
 
4
   This program is free software; you can redistribute it and/or modify
 
5
   it under the terms of the GNU General Public License as published by
 
6
   the Free Software Foundation; version 2 of the License.
 
7
 
 
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.
 
12
 
 
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
 
16
*/
 
17
 
 
18
#include <ndb_global.h>
 
19
 
 
20
#include "Logger.hpp"
 
21
 
 
22
#include <LogHandler.hpp>
 
23
#include <ConsoleLogHandler.hpp>
 
24
#include <FileLogHandler.hpp>
 
25
#include "LogHandlerList.hpp"
 
26
 
 
27
#ifdef _WIN32
 
28
#include "EventLogHandler.hpp"
 
29
#else
 
30
#include <SysLogHandler.hpp>
 
31
#endif
 
32
 
 
33
const char* Logger::LoggerLevelNames[] = { "ON      ", 
 
34
                                           "DEBUG   ",
 
35
                                           "INFO    ",
 
36
                                           "WARNING ",
 
37
                                           "ERROR   ",
 
38
                                           "CRITICAL",
 
39
                                           "ALERT   ",
 
40
                                           "ALL     "
 
41
                                         };
 
42
Logger::Logger() : 
 
43
  m_pCategory("Logger"),
 
44
  m_pConsoleHandler(NULL),
 
45
  m_pFileHandler(NULL),
 
46
  m_pSyslogHandler(NULL)
 
47
{
 
48
  m_pHandlerList = new LogHandlerList();
 
49
  m_mutex= NdbMutex_Create();
 
50
  m_handler_mutex= NdbMutex_Create();
 
51
  disable(LL_ALL);
 
52
  enable(LL_ON);
 
53
  enable(LL_INFO);
 
54
}
 
55
 
 
56
Logger::~Logger()
 
57
{
 
58
  removeAllHandlers();
 
59
  delete m_pHandlerList;
 
60
  NdbMutex_Destroy(m_handler_mutex);
 
61
  NdbMutex_Destroy(m_mutex);
 
62
}
 
63
 
 
64
void 
 
65
Logger::setCategory(const char* pCategory)
 
66
{
 
67
  Guard g(m_mutex);
 
68
  m_pCategory = pCategory;
 
69
}
 
70
 
 
71
bool
 
72
Logger::createConsoleHandler(NdbOut &out)
 
73
{
 
74
  Guard g(m_handler_mutex);
 
75
 
 
76
  if (m_pConsoleHandler)
 
77
    return true; // Ok, already exist
 
78
 
 
79
  LogHandler* log_handler = new ConsoleLogHandler(out);
 
80
  if (!log_handler)
 
81
    return false;
 
82
 
 
83
  if (!addHandler(log_handler))
 
84
  {
 
85
    delete log_handler;
 
86
    return false;
 
87
  }
 
88
 
 
89
  m_pConsoleHandler = log_handler;
 
90
  return true;
 
91
}
 
92
 
 
93
void 
 
94
Logger::removeConsoleHandler()
 
95
{
 
96
  Guard g(m_handler_mutex);
 
97
  if (removeHandler(m_pConsoleHandler))
 
98
  {
 
99
    m_pConsoleHandler = NULL;
 
100
  }
 
101
}
 
102
 
 
103
bool
 
104
Logger::createEventLogHandler(const char* source_name)
 
105
{
 
106
#ifdef _WIN32
 
107
  Guard g(m_handler_mutex);
 
108
 
 
109
  LogHandler* log_handler = new EventLogHandler(source_name);
 
110
  if (!log_handler)
 
111
    return false;
 
112
 
 
113
  if (!addHandler(log_handler))
 
114
  {
 
115
    delete log_handler;
 
116
    return false;
 
117
  }
 
118
 
 
119
  return true;
 
120
#else
 
121
  return false;
 
122
#endif
 
123
}
 
124
 
 
125
bool
 
126
Logger::createFileHandler(char*filename)
 
127
{
 
128
  Guard g(m_handler_mutex);
 
129
 
 
130
  if (m_pFileHandler)
 
131
    return true; // Ok, already exist
 
132
 
 
133
  LogHandler* log_handler = filename ? new FileLogHandler(filename)
 
134
                                     : new FileLogHandler();
 
135
  if (!log_handler)
 
136
    return false;
 
137
 
 
138
  if (!addHandler(log_handler))
 
139
  {
 
140
    delete log_handler;
 
141
    return false;
 
142
  }
 
143
 
 
144
  m_pFileHandler = log_handler;
 
145
  return true;
 
146
}
 
147
 
 
148
void 
 
149
Logger::removeFileHandler()
 
150
{
 
151
  Guard g(m_handler_mutex);
 
152
  if (removeHandler(m_pFileHandler))
 
153
  {
 
154
    m_pFileHandler = NULL;
 
155
  }
 
156
}
 
157
 
 
158
bool
 
159
Logger::createSyslogHandler()
 
160
{
 
161
#ifdef _WIN32
 
162
  return false;
 
163
#else
 
164
  Guard g(m_handler_mutex);
 
165
 
 
166
  if (m_pSyslogHandler)
 
167
    return true; // Ok, already exist
 
168
 
 
169
  LogHandler* log_handler = new SysLogHandler();
 
170
  if (!log_handler)
 
171
    return false;
 
172
 
 
173
  if (!addHandler(log_handler))
 
174
  {
 
175
    delete log_handler;
 
176
    return false;
 
177
  }
 
178
 
 
179
  m_pSyslogHandler = log_handler;
 
180
  return true;
 
181
#endif
 
182
}
 
183
 
 
184
void 
 
185
Logger::removeSyslogHandler()
 
186
{
 
187
  Guard g(m_handler_mutex);
 
188
  if (removeHandler(m_pSyslogHandler))
 
189
  {
 
190
    m_pSyslogHandler = NULL;
 
191
  }
 
192
}
 
193
 
 
194
bool
 
195
Logger::addHandler(LogHandler* pHandler)
 
196
{
 
197
  Guard g(m_mutex);
 
198
  assert(pHandler != NULL);
 
199
 
 
200
  if (!pHandler->is_open() &&
 
201
      !pHandler->open())
 
202
  {
 
203
    // Failed to open
 
204
    return false;
 
205
  }
 
206
 
 
207
  if (!m_pHandlerList->add(pHandler))
 
208
    return false;
 
209
 
 
210
  return true;
 
211
}
 
212
 
 
213
bool
 
214
Logger::addHandler(const BaseString &logstring, int *err, int len, char* errStr) {
 
215
  size_t i;
 
216
  Vector<BaseString> logdest;
 
217
  DBUG_ENTER("Logger::addHandler");
 
218
 
 
219
  logstring.split(logdest, ";");
 
220
 
 
221
  for(i = 0; i < logdest.size(); i++) {
 
222
    DBUG_PRINT("info",("adding: %s",logdest[i].c_str()));
 
223
 
 
224
    Vector<BaseString> v_type_args;
 
225
    logdest[i].split(v_type_args, ":", 2);
 
226
 
 
227
    BaseString type(v_type_args[0]);
 
228
    BaseString params;
 
229
    if(v_type_args.size() >= 2)
 
230
      params = v_type_args[1];
 
231
 
 
232
    LogHandler *handler = NULL;
 
233
 
 
234
#ifndef _WIN32
 
235
    if(type == "SYSLOG")
 
236
    {
 
237
      handler = new SysLogHandler();
 
238
    } else 
 
239
#endif
 
240
    if(type == "FILE")
 
241
      handler = new FileLogHandler();
 
242
    else if(type == "CONSOLE")
 
243
      handler = new ConsoleLogHandler();
 
244
    
 
245
    if(handler == NULL)
 
246
    {
 
247
      BaseString::snprintf(errStr,len,"Could not create log destination: %s",
 
248
                           logdest[i].c_str());
 
249
      DBUG_RETURN(false);
 
250
    }
 
251
 
 
252
    if(!handler->parseParams(params))
 
253
    {
 
254
      *err= handler->getErrorCode();
 
255
      if(handler->getErrorStr())
 
256
        strncpy(errStr, handler->getErrorStr(), len);
 
257
      delete handler;
 
258
      DBUG_RETURN(false);
 
259
    }
 
260
 
 
261
    if (!addHandler(handler))
 
262
    {
 
263
      BaseString::snprintf(errStr,len,"Could not add log destination: %s",
 
264
                           logdest[i].c_str());
 
265
      delete handler;
 
266
      DBUG_RETURN(false);
 
267
    }
 
268
  }
 
269
 
 
270
  DBUG_RETURN(true);
 
271
}
 
272
 
 
273
bool
 
274
Logger::removeHandler(LogHandler* pHandler)
 
275
{
 
276
  Guard g(m_mutex);
 
277
  int rc = false;
 
278
  if (pHandler != NULL)
 
279
  {
 
280
    if (pHandler == m_pConsoleHandler)
 
281
      m_pConsoleHandler= NULL;
 
282
    if (pHandler == m_pFileHandler)
 
283
      m_pFileHandler= NULL;
 
284
    if (pHandler == m_pSyslogHandler)
 
285
      m_pSyslogHandler= NULL;
 
286
 
 
287
    rc = m_pHandlerList->remove(pHandler);
 
288
  }
 
289
 
 
290
  return rc;
 
291
}
 
292
 
 
293
void
 
294
Logger::removeAllHandlers()
 
295
{
 
296
  Guard g(m_mutex);
 
297
  m_pHandlerList->removeAll();
 
298
 
 
299
  m_pConsoleHandler= NULL;
 
300
  m_pFileHandler= NULL;
 
301
  m_pSyslogHandler= NULL;
 
302
}
 
303
 
 
304
bool
 
305
Logger::isEnable(LoggerLevel logLevel) const
 
306
{
 
307
  Guard g(m_mutex);
 
308
  if (logLevel == LL_ALL)
 
309
  {
 
310
    for (unsigned i = 1; i < MAX_LOG_LEVELS; i++)
 
311
      if (!m_logLevels[i])
 
312
        return false;
 
313
    return true;
 
314
  }
 
315
  return m_logLevels[logLevel];
 
316
}
 
317
 
 
318
void
 
319
Logger::enable(LoggerLevel logLevel)
 
320
{
 
321
  Guard g(m_mutex);
 
322
  if (logLevel == LL_ALL)
 
323
  {
 
324
    for (unsigned i = 0; i < MAX_LOG_LEVELS; i++)
 
325
    {
 
326
      m_logLevels[i] = true;
 
327
    }
 
328
  }
 
329
  else 
 
330
  {
 
331
    m_logLevels[logLevel] = true;
 
332
  }
 
333
}
 
334
 
 
335
void 
 
336
Logger::enable(LoggerLevel fromLogLevel, LoggerLevel toLogLevel)
 
337
{
 
338
  Guard g(m_mutex);
 
339
  if (fromLogLevel > toLogLevel)
 
340
  {
 
341
    LoggerLevel tmp = toLogLevel;
 
342
    toLogLevel = fromLogLevel;
 
343
    fromLogLevel = tmp;
 
344
  }
 
345
 
 
346
  for (int i = fromLogLevel; i <= toLogLevel; i++)
 
347
  {
 
348
    m_logLevels[i] = true;
 
349
  } 
 
350
}
 
351
 
 
352
void
 
353
Logger::disable(LoggerLevel logLevel)
 
354
{
 
355
  Guard g(m_mutex);
 
356
  if (logLevel == LL_ALL)
 
357
  {
 
358
    for (unsigned i = 0; i < MAX_LOG_LEVELS; i++)
 
359
    {
 
360
      m_logLevels[i] = false;
 
361
    }
 
362
  }
 
363
  else
 
364
  {
 
365
    m_logLevels[logLevel] = false;
 
366
  }
 
367
}
 
368
 
 
369
void 
 
370
Logger::alert(const char* pMsg, ...) const
 
371
{
 
372
  va_list ap;
 
373
  va_start(ap, pMsg);
 
374
  log(LL_ALERT, pMsg, ap);
 
375
  va_end(ap);
 
376
}
 
377
 
 
378
void 
 
379
Logger::critical(const char* pMsg, ...) const
 
380
{
 
381
  va_list ap;
 
382
  va_start(ap, pMsg);
 
383
  log(LL_CRITICAL, pMsg, ap);  
 
384
  va_end(ap);
 
385
}
 
386
void 
 
387
Logger::error(const char* pMsg, ...) const
 
388
{
 
389
  va_list ap;
 
390
  va_start(ap, pMsg);
 
391
  log(LL_ERROR, pMsg, ap);  
 
392
  va_end(ap);
 
393
}
 
394
void 
 
395
Logger::warning(const char* pMsg, ...) const
 
396
{
 
397
  va_list ap;
 
398
  va_start(ap, pMsg);
 
399
  log(LL_WARNING, pMsg, ap);
 
400
  va_end(ap);
 
401
}
 
402
 
 
403
void 
 
404
Logger::info(const char* pMsg, ...) const
 
405
{
 
406
  va_list ap;
 
407
  va_start(ap, pMsg);
 
408
  log(LL_INFO, pMsg, ap);
 
409
  va_end(ap);
 
410
}
 
411
 
 
412
void 
 
413
Logger::debug(const char* pMsg, ...) const
 
414
{
 
415
  va_list ap;
 
416
  va_start(ap, pMsg);
 
417
  log(LL_DEBUG, pMsg, ap);
 
418
  va_end(ap);
 
419
}
 
420
 
 
421
void 
 
422
Logger::log(LoggerLevel logLevel, const char* pMsg, va_list ap) const
 
423
{
 
424
  Guard g(m_mutex);
 
425
  if (m_logLevels[LL_ON] && m_logLevels[logLevel])
 
426
  {
 
427
    char buf[MAX_LOG_MESSAGE_SIZE];
 
428
    BaseString::vsnprintf(buf, sizeof(buf), pMsg, ap);
 
429
    LogHandler* pHandler = NULL;
 
430
    while ( (pHandler = m_pHandlerList->next()) != NULL)
 
431
    {
 
432
      pHandler->append(m_pCategory, logLevel, buf);
 
433
    }
 
434
  }
 
435
}
 
436
 
 
437
void Logger::setRepeatFrequency(unsigned val)
 
438
{
 
439
  LogHandler* pHandler;
 
440
  while ((pHandler = m_pHandlerList->next()) != NULL)
 
441
  {
 
442
    pHandler->setRepeatFrequency(val);
 
443
  }
 
444
}