How to log?

[syncman]

In C, I would always make a log() function instead of using printfs,
so that I could disable the messages or otherwise process them, all in
one place. This worked in 1 line, for constant strings, but not for
variable values, as in:
char s[99];
sprintf (s, "The value is %d \n", value);
log (s); // 3 lines!!

In C++, is it really as bad as it was? If I use streams:
ostringstream oss;
oss << "The value is " << value << endl;
log (oss.str());
No better!

I suspect the answer might be to use clog:
clog << "The value is " << value << endl;
But I don't see any place where I can later customize or disable.
(I read that clog is the same as cerr, but clog is buffered.)

So, how do people log?

[Ron Natalie]

"syncman" <hs***@hotmail. com> wrote in message news:cc******** *************** ***@posting.goo gle.com...

In C, I would always make a log() function instead of using printfs,

So, how do people log?

We have our own function called
LogPrintf
And our own stream called
LogOut

Based on the programmers inclination, he can either use either one.

[Gianni Mariani]

syncman wrote:

In C, I would always make a log() function instead of using printfs,
so that I could disable the messages or otherwise process them, all in
one place. This worked in 1 line, for constant strings, but not for
variable values, as in:
char s[99];
sprintf (s, "The value is %d \n", value);
log (s); // 3 lines!!

In C++, is it really as bad as it was? If I use streams:
ostringstream oss;
oss << "The value is " << value << endl;
log (oss.str());
No better!

I suspect the answer might be to use clog:
clog << "The value is " << value << endl;
But I don't see any place where I can later customize or disable.
(I read that clog is the same as cerr, but clog is buffered.)

So, how do people log?

I've used a scheme like this one in the past. The actual logging class
was far more flexible than the one below but this example gives you an idea.

The interface is through the macro "LOG" and you pass it a logging level
and a title. The actual levels should be an enum but I just used an int
here for sake of simplicity (in a real system I would use mask).

LOG creates an object named "lout" which upon destruction will output
the log string.

i.e.

LOG( ERROR_LEVEL, "This is an error log" );

of

LOG( WARNING_LEVEL, "This is a warning" )
{
lout.attr( "oil_level" ) << oil_level << " is too low";
} // <<< message string is sent here

If logging is not enabled, no messages are created at all.

If you set the WARNING_LEVEL value to 0, the compiler will eliminate the
warning level logging code entirely.

THE one and only problem I've seen with this technique is that
occationally someone misses the ";" at the end and when logging is
turned on, the code works and when it is not it fails .... cute

I toyed with changing the interface to:

LOG( LOG_LEVEL, "Title" ) END_LOG

to eliminate this possibility of this kind of error but I'm still not
sure it's the best answer. Simplicity is better.

..... here is an example ....

#include <sstream>
#include <iostream>

#define LOG( LEVEL, TITLE ) \
if ( int x_level = (LEVEL) ) \
if ( Logger lout = x_level ) \
if ( lout.Title(TITL E) )
// end

struct LoggerContext
{
std::ostringstr eam m_oss;
int m_level;
mutable int m_count;

LoggerContext( int l_level )
: m_level( l_level ),
m_count( 1 )
{
}

};

struct Logger
{
LoggerContext * m_context;

static int min_level;

Logger( int l_level )
: m_context( l_level >= min_level ? new LoggerContext( l_level )
: 0 )
{
}

bool Title( const char * l_title )
{
m_context->m_oss << l_title << " : ";
return m_context;
}

template <typename T>
Logger & operator << ( const T & value )
{
m_context->m_oss << value;
return * this;
}

Logger & attr( const char * s_attr )
{
m_context->m_oss << " " << s_attr << " = ";
return * this;
}

~Logger()
{
if ( m_context )
{
-- m_context->m_count;
if ( m_context->m_count == 0 )
{
m_context->m_oss << "\n";
/// write log here
std::cout << m_context->m_oss.str();
delete m_context;
}
}
}

operator bool()
{
return m_context;
}

Logger( const Logger & l_rhs )
: m_context( l_rhs.getref() )
{
}

LoggerContext * getref() const
{
++ ( m_context->m_count );
return m_context;
}
};
int Logger::min_lev el = 2;
int main()
{
LOG( 3, "Thing 1" );

LOG( 4, "Thing 2" )
{
lout << "Really " << 33;
lout.attr( "Some value" ) << "54";
lout.attr( "Some other value" ) << 99.33;
}

LOG( 1, "Thing 3" )
{
lout << "Not really";
}

}

[Chrisw]

"Gianni Mariani" <gi*******@mari ani.ws> wrote in message
news:bu******** @dispatch.conce ntric.net...

syncman wrote:

In C, I would always make a log() function instead of using printfs,
so that I could disable the messages or otherwise process them, all in
one place. This worked in 1 line, for constant strings, but not for
variable values, as in:
char s[99];
sprintf (s, "The value is %d \n", value);
log (s); // 3 lines!!

In C++, is it really as bad as it was? If I use streams:
ostringstream oss;
oss << "The value is " << value << endl;
log (oss.str());
No better!

I suspect the answer might be to use clog:
clog << "The value is " << value << endl;
But I don't see any place where I can later customize or disable.
(I read that clog is the same as cerr, but clog is buffered.)

So, how do people log?
I've used a scheme like this one in the past. The actual logging class
was far more flexible than the one below but this example gives you an

idea.
The interface is through the macro "LOG" and you pass it a logging level
and a title. The actual levels should be an enum but I just used an int
here for sake of simplicity (in a real system I would use mask).

LOG creates an object named "lout" which upon destruction will output
the log string.

i.e.

LOG( ERROR_LEVEL, "This is an error log" );

of

LOG( WARNING_LEVEL, "This is a warning" )
{
lout.attr( "oil_level" ) << oil_level << " is too low";
} // <<< message string is sent here

If logging is not enabled, no messages are created at all.

If you set the WARNING_LEVEL value to 0, the compiler will eliminate the
warning level logging code entirely.

THE one and only problem I've seen with this technique is that
occationally someone misses the ";" at the end and when logging is
turned on, the code works and when it is not it fails .... cute

I toyed with changing the interface to:

LOG( LOG_LEVEL, "Title" ) END_LOG

to eliminate this possibility of this kind of error but I'm still not
sure it's the best answer. Simplicity is better.

.... here is an example ....

#include <sstream>
#include <iostream>

#define LOG( LEVEL, TITLE ) \
if ( int x_level = (LEVEL) ) \
if ( Logger lout = x_level ) \
if ( lout.Title(TITL E) )
// end

struct LoggerContext
{
std::ostringstr eam m_oss;
int m_level;
mutable int m_count;

LoggerContext( int l_level )
: m_level( l_level ),
m_count( 1 )
{
}

};

struct Logger
{
LoggerContext * m_context;

static int min_level;

Logger( int l_level )
: m_context( l_level >= min_level ? new LoggerContext( l_level )
: 0 )
{
}

bool Title( const char * l_title )
{
m_context->m_oss << l_title << " : ";
return m_context;
}

template <typename T>
Logger & operator << ( const T & value )
{
m_context->m_oss << value;
return * this;
}

Logger & attr( const char * s_attr )
{
m_context->m_oss << " " << s_attr << " = ";
return * this;
}

~Logger()
{
if ( m_context )
{
-- m_context->m_count;
if ( m_context->m_count == 0 )
{
m_context->m_oss << "\n";
/// write log here
std::cout << m_context->m_oss.str();
delete m_context;
}
}
}

operator bool()
{
return m_context;
}

Logger( const Logger & l_rhs )
: m_context( l_rhs.getref() )
{
}

LoggerContext * getref() const
{
++ ( m_context->m_count );
return m_context;
}
};
int Logger::min_lev el = 2;
int main()
{
LOG( 3, "Thing 1" );

LOG( 4, "Thing 2" )
{
lout << "Really " << 33;
lout.attr( "Some value" ) << "54";
lout.attr( "Some other value" ) << 99.33;
}

LOG( 1, "Thing 3" )
{
lout << "Not really";
}

}

all you have to do is somehting like this:

// log.h
#ifdef LOG_ON
#define LOGNAME "debuglog.t xt"
#define LOG( _S_) { lstream << _S_; }
extern std::ofstream lstream;
#else
#define LOG( _S_)
#endif

//////////////////
// log.cpp
#include "log.h"
#ifdef LOG_ON
#include <fstream>
std::ofstream lstream( LOGNAME );
#endif
// somefile.cpp
#include "log.h"
void func( int n )
{
LOG( "func called with " << n << std::endl );
}
all you have to do to turn logging on/ off is define ( or not, to turn off
logging ) LOG_ON

-Chris

[Jarmo]

"syncman" <hs***@hotmail. com> wrote in message
news:cc******** *************** ***@posting.goo gle.com...

In C, I would always make a log() function instead of using printfs,
so that I could disable the messages or otherwise process them, all in
one place. This worked in 1 line, for constant strings, but not for
variable values, as in:
char s[99];
sprintf (s, "The value is %d \n", value);
log (s); // 3 lines!!

In C++, is it really as bad as it was? If I use streams:
ostringstream oss;
oss << "The value is " << value << endl;
log (oss.str());
No better!

I suspect the answer might be to use clog:
clog << "The value is " << value << endl;
But I don't see any place where I can later customize or disable.
(I read that clog is the same as cerr, but clog is buffered.)

So, how do people log?

Here's an idea in C that makes use of a slightly sneaky preprocessor
feature. No doubt could be made a lot better for C++.

#include <stdio.h>
#include <stdarg.h>

#if defined(DEBUG)
#define TRACE(X) tracefunc X
#else
#define TRACE (void)
#endif

#if defined(DEBUG)
static void tracefunc(char *format, ...)
{
va_list marker;
static FILE *fp = NULL;

if (!fp)
{
fp = fopen("tracef.t rc", "w+t"); // open
}

if (fp)
{
va_start(marker , format);
vfprintf(fp, format, marker);
va_end(marker);
fputc('\n', fp);
fflush(fp);
}
}
#endif

void main(void)
{
int a = 1;
char *b = "BBBB";

TRACE(("a=%d, b=%s", a, b));
TRACE(("b=%s, a=%d", b, a));
}

[Gianni Mariani]

Chrisw wrote:
....

all you have to do is somehting like this:

// log.h
#ifdef LOG_ON
#define LOGNAME "debuglog.t xt"
#define LOG( _S_) { lstream << _S_; }
extern std::ofstream lstream;
#else
#define LOG( _S_)
#endif

//////////////////
// log.cpp
#include "log.h"
#ifdef LOG_ON
#include <fstream>
std::ofstream lstream( LOGNAME );
#endif
// somefile.cpp
#include "log.h"
void func( int n )
{
LOG( "func called with " << n << std::endl );
}
all you have to do to turn logging on/ off is define ( or not, to turn off
logging ) LOG_ON

That's neat but:

a) I want all the code compiled all the time - this reduces errors from
conditionally compiled code. You could fix that here by placing an "if"
around the {}.

b) Logging can become intermixed if the logging itself causes logging to
be used. This also happens when multiple threads are used. I suspect
you could easily fix the macro to do that too.

c) Often what you need to log is more complex than just a message with
fixed parameters

LOG( INFORM_LEVEL, "Attribute dump" )
{
for ( attr_iter = attrs.begin(); ....
lout.attr( *attr.name ) << *attr.value ;
etc...

You could do somthing like:

LOG(
"Log title";
for ( int i = 0; i < 10; i ++ ) {
lstream << i;
}
)

However, now you can't use the operator ,() because the
preprocessor won't know what you mean.

[The Directive]

[Snipped]

#include <stdio.h>
#include <stdarg.h>

#if defined(DEBUG)
#define TRACE(X) tracefunc X
#else
#define TRACE (void)
Why not #define TRACE(X) to nothing, why "(void)"?

#define TRACE(X)

--The Directive
#endif

#if defined(DEBUG)
static void tracefunc(char *format, ...)
{
va_list marker;
static FILE *fp = NULL;

if (!fp)
{
fp = fopen("tracef.t rc", "w+t"); // open
}

if (fp)
{
va_start(marker , format);
vfprintf(fp, format, marker);
va_end(marker);
fputc('\n', fp);
fflush(fp);
}
}
#endif

void main(void)
{
int a = 1;
char *b = "BBBB";

TRACE(("a=%d, b=%s", a, b));
TRACE(("b=%s, a=%d", b, a));
}

[Gianni Mariani]

Jarmo wrote:

"syncman" <hs***@hotmail. com> wrote in message
news:cc******** *************** ***@posting.goo gle.com...

In C, I would always make a log() function instead of using printfs,
so that I could disable the messages or otherwise process them, all in
one place. This worked in 1 line, for constant strings, but not for
variable values, as in:
char s[99];
sprintf (s, "The value is %d \n", value);
log (s); // 3 lines!!

In C++, is it really as bad as it was? If I use streams:
ostringstream oss;
oss << "The value is " << value << endl;
log (oss.str());
No better!

I suspect the answer might be to use clog:
clog << "The value is " << value << endl;
But I don't see any place where I can later customize or disable.
(I read that clog is the same as cerr, but clog is buffered.)

So, how do people log?

Here's an idea in C that makes use of a slightly sneaky preprocessor
feature. No doubt could be made a lot better for C++.

#include <stdio.h>
#include <stdarg.h>

#if defined(DEBUG)
#define TRACE(X) tracefunc X
#else
#define TRACE (void)
#endif

One of *my* biggest issues with conditional complication is that
compiling code conditionally often introduces undetected compilation errors.

#if defined(DEBUG)
#define DOING_DEBUG true
#else
#define DOING_DEBUG false
#endif

#define TRACE(X) if (DOING_DEBUG) { tracefunc X; }

I'd also like to be able to change the behaviour at run time and have
different "levels" of debugging .... but that's another story.

#if defined(DEBUG)
static void tracefunc(char *format, ...)
{
va_list marker;
static FILE *fp = NULL;

if (!fp)
{
fp = fopen("tracef.t rc", "w+t"); // open
}

if (fp)
{
va_start(marker , format);
vfprintf(fp, format, marker);
va_end(marker);
fputc('\n', fp);
fflush(fp);
}
}
#endif

void main(void)
{
int a = 1;
char *b = "BBBB";

TRACE(("a=%d, b=%s", a, b));
TRACE(("b=%s, a=%d", b, a));
}

[Jorge Rivera]

There is a very powerful logging facility called log4cplus. It is a
logging framework for C++ very similar to log4j (for Java, of course).

It allows as simple or as complex logging as you want, and you can set
the logging level dynamically.

I suggest you give that a try, as it might be useful to reuse this
framework instead of having to always write your own custom logging
facilities.

Jorge L

syncman wrote:

In C, I would always make a log() function instead of using printfs,
so that I could disable the messages or otherwise process them, all in
one place. This worked in 1 line, for constant strings, but not for
variable values, as in:
char s[99];
sprintf (s, "The value is %d \n", value);
log (s); // 3 lines!!

In C++, is it really as bad as it was? If I use streams:
ostringstream oss;
oss << "The value is " << value << endl;
log (oss.str());
No better!

I suspect the answer might be to use clog:
clog << "The value is " << value << endl;
But I don't see any place where I can later customize or disable.
(I read that clog is the same as cerr, but clog is buffered.)

So, how do people log?

[Jarmo]

"The Directive" <th***********@ hotmail.com> wrote in message
news:84******** *************** **@posting.goog le.com...

[Snipped]

#include <stdio.h>
#include <stdarg.h>

#if defined(DEBUG)
#define TRACE(X) tracefunc X
#else
#define TRACE (void)

Why not #define TRACE(X) to nothing, why "(void)"?

Good question. If I recall, it was intended to eliminate compiler warnings
on some cranky, old compilers.