- cleaned up logger interface to better integrate with python bindings
- polished and finished python bindings for logger interaction
This commit is contained in:
kunitoki
parent
bfb0f22788
commit
1a203d3f85
3 changed files with 164 additions and 244 deletions
|
|
@ -22,112 +22,48 @@
|
|||
|
||||
#include <boost/python.hpp>
|
||||
#include <mapnik/debug.hpp>
|
||||
|
||||
using mapnik::logger::severity;
|
||||
using mapnik::logger::format;
|
||||
using mapnik::logger::output;
|
||||
|
||||
void set_severity(const severity::type& s)
|
||||
{
|
||||
severity::set(s);
|
||||
}
|
||||
|
||||
severity::type get_severity()
|
||||
{
|
||||
return severity::get();
|
||||
}
|
||||
|
||||
void set_object_severity(const std::string& object_name, const severity::type& s)
|
||||
{
|
||||
severity::set_object(object_name, s);
|
||||
}
|
||||
|
||||
severity::type get_object_severity(const std::string& object_name)
|
||||
{
|
||||
return severity::get_object(object_name);
|
||||
}
|
||||
|
||||
#include <mapnik/utils.hpp>
|
||||
|
||||
void export_logger()
|
||||
{
|
||||
using namespace boost::python;
|
||||
|
||||
enum_<mapnik::logger::severity::type>("SeverityType")
|
||||
.value("Info", severity::info)
|
||||
.value("Debug", severity::debug)
|
||||
.value("Warn", severity::warn)
|
||||
.value("Error", severity::error)
|
||||
.value("Fatal", severity::fatal)
|
||||
.value("None", severity::none)
|
||||
;
|
||||
|
||||
/*
|
||||
using mapnik::logger;
|
||||
using mapnik::singleton;
|
||||
using mapnik::CreateStatic;
|
||||
using namespace boost::python;
|
||||
|
||||
class_<singleton<severity,CreateStatic>,boost::noncopyable>("Singleton",no_init)
|
||||
.def("instance",&singleton<severity,CreateStatic>::instance,
|
||||
class_<singleton<logger,CreateStatic>,boost::noncopyable>("Singleton",no_init)
|
||||
.def("instance",&singleton<logger,CreateStatic>::instance,
|
||||
return_value_policy<reference_existing_object>())
|
||||
.staticmethod("instance")
|
||||
;
|
||||
|
||||
class_<severity,bases<singleton<severity,CreateStatic> >,
|
||||
boost::noncopyable>("Severity",no_init)
|
||||
.def("get",&severity::get)
|
||||
.def("set",&severity::set)
|
||||
.def("get_object",&severity::get_object)
|
||||
.def("set_object",&severity::set_object)
|
||||
.staticmethod("get")
|
||||
.staticmethod("set")
|
||||
.staticmethod("get_object")
|
||||
.staticmethod("set_object")
|
||||
class_<logger,bases<singleton<logger,CreateStatic> >,
|
||||
boost::noncopyable>("logger",no_init)
|
||||
.def_readonly("Info", logger::info)
|
||||
.def_readonly("Debug", logger::debug)
|
||||
.def_readonly("Warn", logger::warn)
|
||||
.def_readonly("Error", logger::error)
|
||||
.def_readonly("Fatal", logger::fatal)
|
||||
.def_readonly("None", logger::none)
|
||||
.def("get_severity", &logger::get_severity)
|
||||
.def("set_severity", &logger::set_severity)
|
||||
.def("get_object_severity", &logger::get_object_severity)
|
||||
.def("set_object_severity", &logger::set_object_severity)
|
||||
.def("clear_object_severity", &logger::clear_object_severity)
|
||||
.def("get_format", &logger::get_format)
|
||||
.def("set_format", &logger::set_format)
|
||||
.def("str", &logger::str)
|
||||
.def("use_file", &logger::use_file)
|
||||
.def("use_console", &logger::use_console)
|
||||
.staticmethod("get_severity")
|
||||
.staticmethod("set_severity")
|
||||
.staticmethod("get_object_severity")
|
||||
.staticmethod("set_object_severity")
|
||||
.staticmethod("clear_object_severity")
|
||||
.staticmethod("get_format")
|
||||
.staticmethod("set_format")
|
||||
.staticmethod("str")
|
||||
.staticmethod("use_file")
|
||||
.staticmethod("use_console")
|
||||
;
|
||||
*/
|
||||
|
||||
def("set_severity", &set_severity,
|
||||
"\n"
|
||||
"Set global logger severity.\n"
|
||||
"\n"
|
||||
"Usage:\n"
|
||||
">>> from mapnik import SeverityType, set_severity\n"
|
||||
">>> set_severity(SeverityType.None)\n"
|
||||
">>> set_severity(SeverityType.Info)\n"
|
||||
">>> set_severity(SeverityType.Debug)\n"
|
||||
">>> set_severity(SeverityType.Warn)\n"
|
||||
">>> set_severity(SeverityType.Error)\n"
|
||||
">>> set_severity(SeverityType.Fatal)\n"
|
||||
);
|
||||
|
||||
def("get_severity", &get_severity,
|
||||
"\n"
|
||||
"Get global logger severity.\n"
|
||||
"\n"
|
||||
"Usage:\n"
|
||||
">>> from mapnik import get_severity\n"
|
||||
">>> get_severity()\n"
|
||||
);
|
||||
|
||||
def("set_object_severity", &set_object_severity,
|
||||
"\n"
|
||||
"Set logger severity for a single object.\n"
|
||||
"\n"
|
||||
"Usage:\n"
|
||||
">>> from mapnik import SeverityType, set_object_severity\n"
|
||||
">>> set_object_severity('ogr', SeverityType.None)\n"
|
||||
">>> set_object_severity('gdal', SeverityType.Info)\n"
|
||||
">>> set_object_severity('cairo_renderer', SeverityType.Debug)\n"
|
||||
">>> set_object_severity('agg_renderer', SeverityType.Warn)\n"
|
||||
">>> set_object_severity('bindings', SeverityType.Error)\n"
|
||||
);
|
||||
|
||||
def("get_object_severity", &get_object_severity,
|
||||
"\n"
|
||||
"Get logger severity for a single object.\n"
|
||||
"\n"
|
||||
"Usage:\n"
|
||||
">>> from mapnik import get_object_severity"
|
||||
">>> get_object_severity('ogr')\n"
|
||||
);
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -43,122 +43,110 @@
|
|||
|
||||
|
||||
namespace mapnik {
|
||||
namespace logger {
|
||||
|
||||
class MAPNIK_DECL severity :
|
||||
public singleton<severity,CreateStatic>,
|
||||
private boost::noncopyable
|
||||
class MAPNIK_DECL logger :
|
||||
public singleton<logger,CreateStatic>,
|
||||
private boost::noncopyable
|
||||
{
|
||||
public:
|
||||
enum severity_type
|
||||
{
|
||||
public:
|
||||
enum type
|
||||
{
|
||||
info,
|
||||
debug,
|
||||
warn,
|
||||
error,
|
||||
fatal,
|
||||
none
|
||||
};
|
||||
info,
|
||||
debug,
|
||||
warn,
|
||||
error,
|
||||
fatal,
|
||||
none
|
||||
};
|
||||
|
||||
typedef boost::unordered_map<std::string, type> severity_map;
|
||||
typedef boost::unordered_map<std::string, severity_type> severity_map;
|
||||
|
||||
// globally get security level
|
||||
static type get()
|
||||
// global security level
|
||||
static severity_type get_severity()
|
||||
{
|
||||
return severity_level_;
|
||||
}
|
||||
|
||||
static void set_severity(const severity_type& severity_level)
|
||||
{
|
||||
#ifdef MAPNIK_THREADSAFE
|
||||
boost::mutex::scoped_lock lock(severity_mutex_);
|
||||
#endif
|
||||
|
||||
severity_level_ = severity_level;
|
||||
}
|
||||
|
||||
// per object security levels
|
||||
static severity_type get_object_severity(const std::string& object_name)
|
||||
{
|
||||
severity_map::iterator it = object_severity_level_.find(object_name);
|
||||
if (object_name.empty() || it == object_severity_level_.end())
|
||||
{
|
||||
return severity_level_;
|
||||
}
|
||||
|
||||
// globally set security level
|
||||
static void set(const type& severity_level)
|
||||
else
|
||||
{
|
||||
#ifdef MAPNIK_THREADSAFE
|
||||
boost::mutex::scoped_lock lock(mutex_);
|
||||
#endif
|
||||
|
||||
severity_level_ = severity_level;
|
||||
return it->second;
|
||||
}
|
||||
}
|
||||
|
||||
// per object get security level
|
||||
static type get_object(const std::string& object_name)
|
||||
{
|
||||
severity_map::iterator it = object_severity_level_.find(object_name);
|
||||
if (object_name.empty() || it == object_severity_level_.end())
|
||||
{
|
||||
return severity_level_;
|
||||
}
|
||||
else
|
||||
{
|
||||
return it->second;
|
||||
}
|
||||
}
|
||||
|
||||
// per object set security level
|
||||
static void set_object(const std::string& object_name,
|
||||
const type& security_level)
|
||||
{
|
||||
#ifdef MAPNIK_THREADSAFE
|
||||
boost::mutex::scoped_lock lock(mutex_);
|
||||
#endif
|
||||
if (! object_name.empty())
|
||||
{
|
||||
object_severity_level_[object_name] = security_level;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
static type severity_level_;
|
||||
static severity_map object_severity_level_;
|
||||
|
||||
#ifdef MAPNIK_THREADSAFE
|
||||
static boost::mutex mutex_;
|
||||
#endif
|
||||
};
|
||||
|
||||
|
||||
class MAPNIK_DECL format :
|
||||
public singleton<format,CreateStatic>,
|
||||
private boost::noncopyable
|
||||
static void set_object_severity(const std::string& object_name,
|
||||
const severity_type& security_level)
|
||||
{
|
||||
public:
|
||||
|
||||
static std::string get()
|
||||
{
|
||||
return format_;
|
||||
}
|
||||
|
||||
static void set(const std::string& format)
|
||||
{
|
||||
#ifdef MAPNIK_THREADSAFE
|
||||
boost::mutex::scoped_lock lock(mutex_);
|
||||
boost::mutex::scoped_lock lock(severity_mutex_);
|
||||
#endif
|
||||
format_ = format;
|
||||
if (! object_name.empty())
|
||||
{
|
||||
object_severity_level_[object_name] = security_level;
|
||||
}
|
||||
}
|
||||
|
||||
static std::string str();
|
||||
|
||||
private:
|
||||
static std::string format_;
|
||||
|
||||
#ifdef MAPNIK_THREADSAFE
|
||||
static boost::mutex mutex_;
|
||||
#endif
|
||||
};
|
||||
|
||||
|
||||
class MAPNIK_DECL output :
|
||||
public singleton<output,CreateStatic>,
|
||||
private boost::noncopyable
|
||||
static void clear_object_severity()
|
||||
{
|
||||
public:
|
||||
static void use_file(const std::string& filepath);
|
||||
static void use_console();
|
||||
#ifdef MAPNIK_THREADSAFE
|
||||
boost::mutex::scoped_lock lock(severity_mutex_);
|
||||
#endif
|
||||
|
||||
private:
|
||||
static std::ofstream file_output_;
|
||||
static std::string file_name_;
|
||||
static std::streambuf* saved_buf_;
|
||||
};
|
||||
object_severity_level_.clear();
|
||||
}
|
||||
|
||||
// format
|
||||
static std::string get_format()
|
||||
{
|
||||
return format_;
|
||||
}
|
||||
|
||||
static void set_format(const std::string& format)
|
||||
{
|
||||
#ifdef MAPNIK_THREADSAFE
|
||||
boost::mutex::scoped_lock lock(format_mutex_);
|
||||
#endif
|
||||
format_ = format;
|
||||
}
|
||||
|
||||
static std::string str();
|
||||
|
||||
// output
|
||||
static void use_file(const std::string& filepath);
|
||||
static void use_console();
|
||||
|
||||
private:
|
||||
static severity_type severity_level_;
|
||||
static severity_map object_severity_level_;
|
||||
static std::string format_;
|
||||
static std::ofstream file_output_;
|
||||
static std::string file_name_;
|
||||
static std::streambuf* saved_buf_;
|
||||
|
||||
#ifdef MAPNIK_THREADSAFE
|
||||
static boost::mutex severity_mutex_;
|
||||
static boost::mutex format_mutex_;
|
||||
#endif
|
||||
};
|
||||
|
||||
|
||||
namespace detail {
|
||||
|
||||
template<class Ch, class Tr, class A>
|
||||
class clog_sink
|
||||
|
|
@ -166,19 +154,19 @@ namespace mapnik {
|
|||
public:
|
||||
typedef std::basic_ostringstream<Ch, Tr, A> stream_buffer;
|
||||
|
||||
void operator()(const stream_buffer &s)
|
||||
void operator()(const logger::severity_type& severity, const stream_buffer &s)
|
||||
{
|
||||
#ifdef MAPNIK_THREADSAFE
|
||||
static boost::mutex mutex;
|
||||
boost::mutex::scoped_lock lock(mutex);
|
||||
#endif
|
||||
std::clog << format::str() << " " << s.str() << std::endl;
|
||||
std::clog << logger::str() << " " << s.str() << std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<template <class Ch, class Tr, class A> class OutputPolicy,
|
||||
severity::type Severity,
|
||||
logger::severity_type Severity,
|
||||
class Ch = char,
|
||||
class Tr = std::char_traits<Ch>,
|
||||
class A = std::allocator<Ch> >
|
||||
|
|
@ -204,7 +192,7 @@ namespace mapnik {
|
|||
#ifdef MAPNIK_LOG
|
||||
if (check_severity())
|
||||
{
|
||||
output_policy()(streambuf_);
|
||||
output_policy()(Severity, streambuf_);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
|
@ -222,7 +210,7 @@ namespace mapnik {
|
|||
#ifdef MAPNIK_LOG
|
||||
inline bool check_severity()
|
||||
{
|
||||
return Severity >= severity::get_object(object_name_);
|
||||
return Severity >= logger::get_object_severity(object_name_);
|
||||
}
|
||||
|
||||
typename output_policy::stream_buffer streambuf_;
|
||||
|
|
@ -230,45 +218,46 @@ namespace mapnik {
|
|||
#endif
|
||||
};
|
||||
|
||||
typedef base_log<clog_sink, severity::info> base_log_info;
|
||||
typedef base_log<clog_sink, severity::debug> base_log_debug;
|
||||
typedef base_log<clog_sink, severity::warn> base_log_warn;
|
||||
typedef base_log<clog_sink, severity::error> base_log_error;
|
||||
typedef base_log<clog_sink, severity::fatal> base_log_fatal;
|
||||
}
|
||||
typedef base_log<clog_sink, logger::info> base_log_info;
|
||||
typedef base_log<clog_sink, logger::debug> base_log_debug;
|
||||
typedef base_log<clog_sink, logger::warn> base_log_warn;
|
||||
typedef base_log<clog_sink, logger::error> base_log_error;
|
||||
typedef base_log<clog_sink, logger::fatal> base_log_fatal;
|
||||
|
||||
} // namespace detail
|
||||
|
||||
class MAPNIK_DECL info : public logger::base_log_info {
|
||||
// real interfaces
|
||||
class MAPNIK_DECL info : public detail::base_log_info {
|
||||
public:
|
||||
info() : logger::base_log_info() {}
|
||||
info(const char* object_name) : logger::base_log_info(object_name) {}
|
||||
info() : detail::base_log_info() {}
|
||||
info(const char* object_name) : detail::base_log_info(object_name) {}
|
||||
};
|
||||
|
||||
class MAPNIK_DECL debug : public logger::base_log_debug {
|
||||
class MAPNIK_DECL debug : public detail::base_log_debug {
|
||||
public:
|
||||
debug() : logger::base_log_debug() {}
|
||||
debug(const char* object_name) : logger::base_log_debug(object_name) {}
|
||||
debug() : detail::base_log_debug() {}
|
||||
debug(const char* object_name) : detail::base_log_debug(object_name) {}
|
||||
};
|
||||
|
||||
class MAPNIK_DECL warn : public logger::base_log_warn {
|
||||
class MAPNIK_DECL warn : public detail::base_log_warn {
|
||||
public:
|
||||
warn() : logger::base_log_warn() {}
|
||||
warn(const char* object_name) : logger::base_log_warn(object_name) {}
|
||||
warn() : detail::base_log_warn() {}
|
||||
warn(const char* object_name) : detail::base_log_warn(object_name) {}
|
||||
};
|
||||
|
||||
class MAPNIK_DECL error : public logger::base_log_error {
|
||||
class MAPNIK_DECL error : public detail::base_log_error {
|
||||
public:
|
||||
error() : logger::base_log_error() {}
|
||||
error(const char* object_name) : logger::base_log_error(object_name) {}
|
||||
error() : detail::base_log_error() {}
|
||||
error(const char* object_name) : detail::base_log_error(object_name) {}
|
||||
};
|
||||
|
||||
class MAPNIK_DECL fatal : public logger::base_log_fatal {
|
||||
class MAPNIK_DECL fatal : public detail::base_log_fatal {
|
||||
public:
|
||||
fatal() : logger::base_log_fatal() {}
|
||||
fatal(const char* object_name) : logger::base_log_fatal(object_name) {}
|
||||
fatal() : detail::base_log_fatal() {}
|
||||
fatal(const char* object_name) : detail::base_log_fatal(object_name) {}
|
||||
};
|
||||
|
||||
|
||||
// logging helpers
|
||||
#define MAPNIK_LOG_INFO(s) mapnik::info(#s)
|
||||
#define MAPNIK_LOG_DEBUG(s) mapnik::debug(#s)
|
||||
#define MAPNIK_LOG_WARN(s) mapnik::warn(#s)
|
||||
|
|
|
|||
|
|
@ -30,54 +30,51 @@
|
|||
#define MAPNIK_LOG_FORMAT "Mapnik LOG> %Y-%m-%d %H:%M:%S:"
|
||||
#endif
|
||||
|
||||
namespace mapnik { namespace logger {
|
||||
namespace mapnik {
|
||||
|
||||
#ifdef MAPNIK_THREADSAFE
|
||||
boost::mutex logger::severity_mutex_;
|
||||
boost::mutex logger::format_mutex_;
|
||||
#endif
|
||||
|
||||
|
||||
// severity
|
||||
|
||||
severity::type severity::severity_level_ =
|
||||
logger::severity_type logger::severity_level_ =
|
||||
#ifdef MAPNIK_DEBUG
|
||||
severity::debug
|
||||
logger::debug
|
||||
#else
|
||||
severity::error
|
||||
logger::error
|
||||
#endif
|
||||
;
|
||||
|
||||
severity::severity_map severity::object_severity_level_ = severity::severity_map();
|
||||
|
||||
#ifdef MAPNIK_THREADSAFE
|
||||
boost::mutex severity::mutex_;
|
||||
#endif
|
||||
logger::severity_map logger::object_severity_level_ = logger::severity_map();
|
||||
|
||||
|
||||
// format
|
||||
|
||||
#define __xstr__(s) __str__(s)
|
||||
#define __str__(s) #s
|
||||
std::string format::format_ = __xstr__(MAPNIK_LOG_FORMAT);
|
||||
std::string logger::format_ = __xstr__(MAPNIK_LOG_FORMAT);
|
||||
#undef __xstr__
|
||||
#undef __str__
|
||||
|
||||
#ifdef MAPNIK_THREADSAFE
|
||||
boost::mutex format::mutex_;
|
||||
#endif
|
||||
|
||||
std::string format::str()
|
||||
std::string logger::str()
|
||||
{
|
||||
char buf[256];
|
||||
const time_t tm = time(0);
|
||||
strftime(buf, sizeof(buf), format::format_.c_str(), localtime(&tm));
|
||||
strftime(buf, sizeof(buf), logger::format_.c_str(), localtime(&tm));
|
||||
return buf;
|
||||
}
|
||||
|
||||
|
||||
// output
|
||||
|
||||
std::ofstream output::file_output_;
|
||||
std::string output::file_name_;
|
||||
std::streambuf* output::saved_buf_ = 0;
|
||||
std::ofstream logger::file_output_;
|
||||
std::string logger::file_name_;
|
||||
std::streambuf* logger::saved_buf_ = 0;
|
||||
|
||||
void output::use_file(const std::string& filepath)
|
||||
void logger::use_file(const std::string& filepath)
|
||||
{
|
||||
// save clog rdbuf
|
||||
if (saved_buf_ == 0)
|
||||
|
|
@ -109,7 +106,7 @@ void output::use_file(const std::string& filepath)
|
|||
}
|
||||
}
|
||||
|
||||
void output::use_console()
|
||||
void logger::use_console()
|
||||
{
|
||||
// save clog rdbuf
|
||||
if (saved_buf_ == 0)
|
||||
|
|
@ -120,6 +117,4 @@ void output::use_console()
|
|||
std::clog.rdbuf(saved_buf_);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue