Branch data     Line data    Source code

       1                 :            : // $Id: DebugLogger.cc 4771 2007-08-11 05:50:24Z vern $
       2                 :            : 
       3                 :            : #ifdef DEBUG
       4                 :            : 
       5                 :            : #include <stdlib.h>
       6                 :            : #include <unistd.h>
       7                 :            : 
       8                 :            : #include "DebugLogger.h"
       9                 :            : #include "Net.h"
      10                 :            : 
      11                 :          6 : DebugLogger debug_logger("debug");
      12                 :            : 
      13                 :            : // Same order here as in DebugStream.
      14                 :            : DebugLogger::Stream DebugLogger::streams[NUM_DBGS] = {
      15                 :            :         { "serial", 0, false }, { "rules", 0, false }, { "comm", 0, false },
      16                 :            :         { "state", 0, false }, { "chunkedio", 0, false },
      17                 :            :         { "compressor", 0, false }, {"string", 0, false },
      18                 :            :         { "notifiers", 0, false },  { "main-loop", 0, false },
      19                 :            :         { "dpd", 0, false }, { "tm", 0, false },
      20                 :            : };
      21                 :            : 
      22                 :          3 : DebugLogger::DebugLogger(const char* filename)
      23                 :            :         {
      24 [ +  - ][ #  # ]:          3 :         if ( filename )
      25                 :            :                 {
      26                 :          3 :                 filename = log_file_name(filename);
      27                 :            :                 
      28                 :          3 :                 file = fopen(filename, "w");
      29   [ -  +  #  # ]:          3 :                 if ( ! file )
      30                 :            :                         {
      31                 :          0 :                         fprintf(stderr, "Can't open '%s' for debugging output.", filename);
      32                 :          0 :                         exit(1);
      33                 :            :                         }
      34                 :            : 
      35                 :          3 :                 setvbuf(file, NULL, _IOLBF, 0);
      36                 :            :                 }
      37                 :            :         else
      38                 :          0 :                 file = stderr;
      39                 :            : 
      40                 :          3 :         verbose = false;
      41                 :          3 :         }
      42                 :            : 
      43                 :          3 : DebugLogger::~DebugLogger()
      44                 :            :         {
      45 [ +  - ][ #  # ]:          3 :         if ( file != stderr )
      46                 :          3 :                 fclose(file);
      47                 :          3 :         }
      48                 :            : 
      49                 :          0 : void DebugLogger::EnableStreams(const char* s)
      50                 :            :         {
      51                 :          0 :         char* tmp = copy_string(s);
      52                 :            :         char* brkt;
      53                 :          0 :         char* tok = strtok(tmp, ",");
      54                 :            : 
      55         [ #  # ]:          0 :         while ( tok )
      56                 :            :                 {
      57                 :            :                 int i;
      58         [ #  # ]:          0 :                 for ( i = 0; i < NUM_DBGS; ++i )
      59         [ #  # ]:          0 :                         if ( strcasecmp(streams[i].prefix, tok) == 0 )
      60                 :            :                                 {
      61                 :          0 :                                 streams[i].enabled = true;
      62                 :          0 :                                 break;
      63                 :            :                                 }
      64                 :            : 
      65         [ #  # ]:          0 :                 if ( i == NUM_DBGS )
      66                 :            :                         {
      67         [ #  # ]:          0 :                         if ( strcasecmp("verbose", tok) == 0 )
      68                 :          0 :                                 verbose = true;
      69                 :            :                         else
      70                 :          0 :                                 internal_error("unknown debug stream %s\n", tok);
      71                 :            :                         }
      72                 :            : 
      73                 :          0 :                 tok = strtok(0, ",");
      74                 :            :                 }
      75                 :          0 :         }
      76                 :            : 
      77                 :     276726 : void DebugLogger::Log(DebugStream stream, const char* fmt, ...)
      78                 :            :         {
      79                 :     276726 :         Stream* g = &streams[int(stream)];
      80                 :            : 
      81         [ +  - ]:     276726 :         if ( ! g->enabled )
      82                 :     276726 :                 return;
      83                 :            : 
      84                 :            :         fprintf(file, "%17.06f/%17.06f [%s] ",
      85                 :          0 :                         network_time, current_time(true), g->prefix);
      86                 :            : 
      87         [ #  # ]:          0 :         for ( int i = g->indent; i > 0; --i )
      88                 :          0 :                 fputs("   ", file);
      89                 :            : 
      90                 :            :         va_list ap;
      91                 :          0 :         va_start(ap, fmt);
      92                 :          0 :         vfprintf(file, fmt, ap);
      93                 :          0 :         va_end(ap);
      94                 :            : 
      95                 :          0 :         fputc('\n', file);
      96                 :     276726 :         fflush(file);
      97 [ +  - ][ +  - ]:          6 :         }
      98                 :          3 : 
      99                 :            : #endif