diff --git a/bindings/python/mapnik_datasource.cpp b/bindings/python/mapnik_datasource.cpp
index 7d424431d..f89b4eb01 100644
--- a/bindings/python/mapnik_datasource.cpp
+++ b/bindings/python/mapnik_datasource.cpp
@@ -90,7 +90,6 @@ boost::python::dict describe(boost::shared_ptr<mapnik::datasource> const& ds)
     description["name"] = ld.get_name();
     description["geometry_type"] = ds->get_geometry_type();
     description["encoding"] = ld.get_encoding();
-    description["log"] = ds->log_enabled();
     return description;
 }
 
diff --git a/bindings/python/mapnik_logger.cpp b/bindings/python/mapnik_logger.cpp
new file mode 100644
index 000000000..403960fc7
--- /dev/null
+++ b/bindings/python/mapnik_logger.cpp
@@ -0,0 +1,65 @@
+/*****************************************************************************
+ *
+ * This file is part of Mapnik (c++ mapping toolkit)
+ *
+ * Copyright (C) 2006 Artem Pavlenko, Jean-Francois Doyon
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ *****************************************************************************/
+
+#include <boost/python.hpp>
+#include <mapnik/debug.hpp>
+
+void export_logger()
+{
+    // TODO - expose the logger global class
+
+    /*
+    using namespace boost::python;
+
+    enum_<mapnik::logger::severity::type>("severity")
+        .value("Info", mapnik::logger::severity::info)
+        .value("Debug", mapnik::logger::severity::debug)
+        .value("Warn", mapnik::logger::severity::warn)
+        .value("Error", mapnik::logger::severity::error)
+        .value("Fatal", mapnik::logger::severity::fatal)
+        .value("None", mapnik::logger::severity::none)
+        ;
+    */
+
+    /*
+    using mapnik::freetype_engine;
+    using mapnik::singleton;
+    using mapnik::CreateStatic;
+    using namespace boost::python;
+    class_<singleton<freetype_engine,CreateStatic>,boost::noncopyable>("Singleton",no_init)
+        .def("instance",&singleton<freetype_engine,CreateStatic>::instance,
+             return_value_policy<reference_existing_object>())
+        .staticmethod("instance")
+        ;
+
+    class_<freetype_engine,bases<singleton<freetype_engine,CreateStatic> >,
+        boost::noncopyable>("FontEngine",no_init)
+        .def("register_font",&freetype_engine::register_font)
+        .def("register_fonts",&freetype_engine::register_fonts)
+        .def("face_names",&freetype_engine::face_names)
+        .staticmethod("register_font")
+        .staticmethod("register_fonts")
+        .staticmethod("face_names")
+        ;
+
+    */
+}
diff --git a/bindings/python/mapnik_python.cpp b/bindings/python/mapnik_python.cpp
index 4a4f5c4c9..6020d3b16 100644
--- a/bindings/python/mapnik_python.cpp
+++ b/bindings/python/mapnik_python.cpp
@@ -67,6 +67,7 @@ void export_view_transform();
 void export_raster_colorizer();
 void export_inmem_metawriter();
 void export_label_collision_detector();
+void export_logger();
 
 #include <mapnik/version.hpp>
 #include <mapnik/value_error.hpp>
@@ -386,6 +387,7 @@ BOOST_PYTHON_MODULE(_mapnik)
     export_raster_colorizer();
     export_inmem_metawriter();
     export_label_collision_detector();
+    export_logger();
 
     def("render_grid",&render_grid,
         ( arg("map"),
diff --git a/include/mapnik/datasource.hpp b/include/mapnik/datasource.hpp
index 0e7b71f7c..6ae828a94 100644
--- a/include/mapnik/datasource.hpp
+++ b/include/mapnik/datasource.hpp
@@ -88,7 +88,6 @@ public:
 
     datasource (parameters const& params)
       : params_(params),
-        log_enabled_(false),
         is_bound_(false)
     {
     }
@@ -105,15 +104,6 @@ public:
         return params_;
     }
 
-    /*!
-     * @brief Get the status of detasource logging
-     * @return Return true if log is enabled, false otherwise
-     */
-    bool log_enabled() const
-    {
-        return log_enabled_;
-    }
-
     /*!
      * @brief Get the type of the datasource
      * @return The type of the datasource (Vector or Raster)
@@ -133,7 +123,6 @@ public:
     virtual ~datasource() {}
 protected:
     parameters params_;
-    bool log_enabled_;
     mutable bool is_bound_;
 };
 
diff --git a/include/mapnik/debug.hpp b/include/mapnik/debug.hpp
index 23d916f4c..9d7f25c1e 100644
--- a/include/mapnik/debug.hpp
+++ b/include/mapnik/debug.hpp
@@ -29,10 +29,16 @@
 #define MAPNIK_DEBUG_AS_BOOL false
 #endif
 
+#ifndef MAPNIK_LOG_FORMAT
+#define MAPNIK_LOG_FORMAT "Mapnik LOG> %Y-%m-%d %H:%M:%S:"
+#endif
+
 // mapnik (should not depend on anything else)
 #include <mapnik/config.hpp>
 
 // boost
+#include <boost/utility.hpp>
+#include <boost/unordered_map.hpp>
 #ifdef MAPNIK_THREADSAFE
 #include <boost/thread/mutex.hpp>
 #endif
@@ -44,15 +50,10 @@
 #include <ctime>
 #include <ostream>
 #include <fstream>
+#include <string>
 
-#ifdef MAPNIK_LOG
-
-#ifndef MAPNIK_LOG_FORMAT
-#error Must run configure again to regenerate the correct log format string. See LOG_FORMAT_STRING scons option.
-#endif
 
 namespace mapnik {
-
     namespace logger {
 
         class severity
@@ -68,22 +69,66 @@ namespace mapnik {
                 none
             };
 
-            static type get() {
+            typedef boost::unordered_map<std::string, type> severity_map;
+
+            // globally get security level
+            static type get()
+            {
                 return severity_level_;
             }
-            static void set(const type& severity_level) {
+
+            // globally set security level
+            static void set(const type& severity_level)
+            {
+#ifdef MAPNIK_THREADSAFE
+                boost::mutex::scoped_lock lock(mutex_);
+#endif
+
                 severity_level_ = severity_level;
             }
 
+            // 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
         };
 
 
 #define __xstr__(s) __str__(s)
 #define __str__(s) #s
 
-        static inline std::string format_logger() {
+        static inline std::string format_logger()
+        {
             char buf[256];
             const time_t tm = time(0);
             strftime(buf, sizeof(buf), __xstr__(MAPNIK_LOG_FORMAT), localtime(&tm));
@@ -94,29 +139,37 @@ namespace mapnik {
 #undef __str__
 
 
+#if 0
         template<class Ch, class Tr, class A>
-        class no_output {
+        class no_output
+        {
         private:
-            struct null_buffer {
+            struct null_buffer
+            {
                 template<class T>
-                null_buffer &operator<<(const T &) {
+                null_buffer &operator<<(const T &)
+                {
                     return *this;
                 }
             };
-        public:
+
             typedef null_buffer stream_buffer;
-        public:
-            void operator()(const stream_buffer &) {
+
+            void operator()(const stream_buffer &)
+            {
             }
         };
+#endif
 
 
         template<class Ch, class Tr, class A>
-        class output_to_clog {
+        class output_to_clog
+        {
         public:
             typedef std::basic_ostringstream<Ch, Tr, A> stream_buffer;
-        public:
-            void operator()(const stream_buffer &s) {
+
+            void operator()(const stream_buffer &s)
+            {
 #ifdef MAPNIK_THREADSAFE
                 static boost::mutex mutex;
                 boost::mutex::scoped_lock lock(mutex);
@@ -131,45 +184,103 @@ namespace mapnik {
                  class Ch = char,
                  class Tr = std::char_traits<Ch>,
                  class A = std::allocator<Ch> >
-        class base_log {
+        class base_log : public boost::noncopyable
+        {
+        public:
             typedef OutputPolicy<Ch, Tr, A> output_policy;
-        public:
-            ~base_log() {
-                if (Severity >= severity::get())
-                    output_policy()(streambuf_);
+
+            base_log() {}
+
+            base_log(const char* object_name)
+            {
+                if (object_name != NULL)
+                {
+                    object_name_ = object_name;
+                }
             }
-        public:
+
+            ~base_log()
+            {
+                if (check_severity())
+                {
+                    output_policy()(streambuf_);
+                }
+            }
+
             template<class T>
-            base_log &operator<<(const T &x) {
+            base_log &operator<<(const T &x)
+            {
                 streambuf_ << x;
                 return *this;
             }
+
         private:
+            inline bool check_severity()
+            {
+                return Severity >= severity::get_object(object_name_);
+            }
+
             typename output_policy::stream_buffer streambuf_;
+            std::string object_name_;
         };
     }
 
 
     class MAPNIK_DECL log : public logger::base_log<logger::output_to_clog,
-            logger::severity::debug> {};
+            logger::severity::debug> {
+    public:
+        typedef logger::base_log<logger::output_to_clog, logger::severity::debug> base_class;
+        log(const char* object_name) : base_class(object_name) {}
+        log() : base_class() {}
+    };
 
     class MAPNIK_DECL info : public logger::base_log<logger::output_to_clog,
-            logger::severity::info> {};
+            logger::severity::info> {
+    public:
+        typedef logger::base_log<logger::output_to_clog, logger::severity::info> base_class;
+        info(const char* object_name) : base_class(object_name) {}
+        info() : base_class() {}
+    };
 
     class MAPNIK_DECL debug : public logger::base_log<logger::output_to_clog,
-            logger::severity::debug> {};
+            logger::severity::debug> {
+    public:
+        typedef logger::base_log<logger::output_to_clog, logger::severity::debug> base_class;
+        debug(const char* object_name) : base_class(object_name) {}
+        debug() : base_class() {}
+    };
 
     class MAPNIK_DECL warn : public logger::base_log<logger::output_to_clog,
-            logger::severity::warn> {};
+            logger::severity::warn> {
+    public:
+        typedef logger::base_log<logger::output_to_clog, logger::severity::warn> base_class;
+        warn(const char* object_name) : base_class(object_name) {}
+        warn() : base_class() {}
+    };
 
     class MAPNIK_DECL error : public logger::base_log<logger::output_to_clog,
-            logger::severity::error> {};
+            logger::severity::error> {
+    public:
+        typedef logger::base_log<logger::output_to_clog, logger::severity::error> base_class;
+        error(const char* object_name) : base_class(object_name) {}
+        error() : base_class() {}
+    };
 
     class MAPNIK_DECL fatal : public logger::base_log<logger::output_to_clog,
-            logger::severity::fatal> {};
+            logger::severity::fatal> {
+    public:
+        typedef logger::base_log<logger::output_to_clog, logger::severity::fatal> base_class;
+        fatal(const char* object_name) : base_class(object_name) {}
+        fatal() : base_class() {}
+    };
+
+
+    #define MAPNIK_LOG_INFO(s) mapnik::info(#s)
+    #define MAPNIK_LOG_DEBUG(s) mapnik::debug(#s)
+    #define MAPNIK_LOG_WARN(s) mapnik::warn(#s)
+    #define MAPNIK_LOG_ERROR(s) mapnik::error(#s)
+    #define MAPNIK_LOG_FATAL(s) mapnik::fatal(#s)
 
 }
 
-#endif // MAPNIK_LOG
-
 #endif // MAPNIK_DEBUG_HPP
diff --git a/plugins/input/csv/csv_datasource.cpp b/plugins/input/csv/csv_datasource.cpp
index 4a65c8000..d0997e1ad 100644
--- a/plugins/input/csv/csv_datasource.cpp
+++ b/plugins/input/csv/csv_datasource.cpp
@@ -72,8 +72,6 @@ csv_datasource::csv_datasource(parameters const& params, bool bind)
       filesize_max_(*params_.get<float>("filesize_max", 20.0)),  // MB
       ctx_(boost::make_shared<mapnik::context_type>())
 {
-    log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
-
     /* TODO:
        general:
        - refactor parser into generic class
@@ -224,7 +222,7 @@ void csv_datasource::parse_csv(T& stream,
                 sep = "\t";
 
 #ifdef MAPNIK_LOG
-                if (log_enabled_) mapnik::log() << "csv_datasource: auto detected tab separator";
+                MAPNIK_LOG_DEBUG(csv) << "csv_datasource: auto detected tab separator";
 #endif
             }
         }
@@ -236,7 +234,7 @@ void csv_datasource::parse_csv(T& stream,
                 sep = "|";
 
 #ifdef MAPNIK_LOG
-                if (log_enabled_) mapnik::log() << "csv_datasource: auto detected '|' separator";
+                MAPNIK_LOG_DEBUG(csv) << "csv_datasource: auto detected '|' separator";
 #endif
             }
             else // semicolons
@@ -247,7 +245,7 @@ void csv_datasource::parse_csv(T& stream,
                     sep = ";";
 
 #ifdef MAPNIK_LOG
-                    if (log_enabled_) mapnik::log() << "csv_datasource: auto detected ';' separator";
+                    MAPNIK_LOG_DEBUG(csv) << "csv_datasource: auto detected ';' separator";
 #endif
                 }
             }
@@ -266,7 +264,7 @@ void csv_datasource::parse_csv(T& stream,
     if (quo.empty()) quo = "\"";
 
 #ifdef MAPNIK_LOG
-    if (log_enabled_) mapnik::log() << "csv_datasource: csv grammer: sep: '" << sep << "' quo: '" << quo << "' esc: '" << esc;
+    MAPNIK_LOG_DEBUG(csv) << "csv_datasource: csv grammer: sep: '" << sep << "' quo: '" << quo << "' esc: '" << esc;
 #endif
 
     boost::escaped_list_separator<char> grammer;
@@ -433,7 +431,7 @@ void csv_datasource::parse_csv(T& stream,
         if ((row_limit_ > 0) && (line_number > row_limit_))
         {
 #ifdef MAPNIK_LOG
-            if (log_enabled_) mapnik::log() << "csv_datasource: row limit hit, exiting at feature: " << feature_count;
+            MAPNIK_LOG_DEBUG(csv) << "csv_datasource: row limit hit, exiting at feature: " << feature_count;
 #endif
             break;
         }
@@ -450,7 +448,7 @@ void csv_datasource::parse_csv(T& stream,
                 ++line_number;
 
 #ifdef MAPNIK_LOG
-                if (log_enabled_) mapnik::log() << "csv_datasource: empty row encountered at line: " << line_number;
+                MAPNIK_LOG_DEBUG(csv) << "csv_datasource: empty row encountered at line: " << line_number;
 #endif
 
                 continue;
@@ -555,8 +553,7 @@ void csv_datasource::parse_csv(T& stream,
                                 }
                                 else
                                 {
-                                    // TODO - handle this with mapnik::log
-                                    if (!quiet_) std::cerr << s.str() << "\n";
+                                    MAPNIK_LOG_ERROR(csv) << s.str();
                                 }
                             }
                         }
@@ -580,8 +577,7 @@ void csv_datasource::parse_csv(T& stream,
                                 }
                                 else
                                 {
-                                    // TODO - handle this with mapnik::log
-                                    if (!quiet_) std::cerr << s.str() << "\n";
+                                    MAPNIK_LOG_ERROR(csv) << s.str();
                                 }
                             }
                         }
@@ -618,8 +614,7 @@ void csv_datasource::parse_csv(T& stream,
                             }
                             else
                             {
-                                // TODO - handle this with mapnik::log
-                                if (!quiet_) std::cerr << s.str() << "\n";
+                                MAPNIK_LOG_ERROR(csv) << s.str();
                             }
                         }
                     }
@@ -652,8 +647,7 @@ void csv_datasource::parse_csv(T& stream,
                             }
                             else
                             {
-                                // TODO - handle this with mapnik::log
-                                if (!quiet_) std::cerr << s.str() << "\n";
+                                MAPNIK_LOG_ERROR(csv) << s.str();
                             }
                         }
                     }
@@ -746,8 +740,7 @@ void csv_datasource::parse_csv(T& stream,
                 }
                 else
                 {
-                    // TODO - handle this with mapnik::log
-                    if (!quiet_) std::cerr << s.str() << "\n";
+                    MAPNIK_LOG_ERROR(csv) << s.str();
                     continue;
                 }
             }
@@ -780,8 +773,7 @@ void csv_datasource::parse_csv(T& stream,
                     }
                     else
                     {
-                        // TODO - handle this with mapnik::log
-                        if (!quiet_) std::cerr << s.str() << "\n";
+                        MAPNIK_LOG_ERROR(csv) << s.str();
                         continue;
                     }
                 }
@@ -832,8 +824,7 @@ void csv_datasource::parse_csv(T& stream,
                     }
                     else
                     {
-                        // TODO - handle this with mapnik::log
-                        if (!quiet_) std::cerr << s.str() << "\n";
+                        MAPNIK_LOG_ERROR(csv) << s.str();
                         continue;
                     }
                 }
@@ -848,8 +839,7 @@ void csv_datasource::parse_csv(T& stream,
             }
             else
             {
-                // TODO - handle this with mapnik::log
-                if (!quiet_) std::cerr << ex.what() << "\n";
+                MAPNIK_LOG_ERROR(csv) << ex.what();
             }
         }
         catch(const std::exception & ex)
@@ -864,15 +854,13 @@ void csv_datasource::parse_csv(T& stream,
             }
             else
             {
-                // TODO - handle this with mapnik::log
-                if (!quiet_) std::cerr << s.str() << "\n";
+                MAPNIK_LOG_ERROR(csv) << s.str();
             }
         }
     }
     if (!feature_count > 0)
     {
-        // TODO - handle this with mapnik::log
-        if (!quiet_) std::cerr << "CSV Plugin: could not parse any lines of data\n";
+        MAPNIK_LOG_ERROR(csv) << "CSV Plugin: could not parse any lines of data";
     }
 }
 
diff --git a/plugins/input/gdal/gdal_datasource.cpp b/plugins/input/gdal/gdal_datasource.cpp
index 5f603ee57..226eb8719 100644
--- a/plugins/input/gdal/gdal_datasource.cpp
+++ b/plugins/input/gdal/gdal_datasource.cpp
@@ -51,7 +51,7 @@ using mapnik::datasource_exception;
 inline GDALDataset* gdal_datasource::open_dataset() const
 {
 #ifdef MAPNIK_LOG
-    if (log_enabled_) mapnik::log() << "gdal_datasource: Opening " << dataset_name_;
+    MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource: Opening " << dataset_name_;
 #endif
 
     GDALDataset *dataset;
@@ -81,10 +81,8 @@ gdal_datasource::gdal_datasource(parameters const& params, bool bind)
       filter_factor_(*params_.get<double>("filter_factor", 0.0)),
       nodata_value_(params_.get<double>("nodata"))
 {
-    log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
-
 #ifdef MAPNIK_LOG
-    if (log_enabled_) mapnik::log() << "gdal_datasource: Initializing...";
+    MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource: Initializing...";
 #endif
 
     GDALAllRegister();
@@ -131,7 +129,7 @@ void gdal_datasource::bind() const
     if (bbox_s)
     {
 #ifdef MAPNIK_LOG
-        if (log_enabled_) mapnik::log() << "gdal_datasource: BBox Parameter=" << *bbox_s;
+        MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource: BBox Parameter=" << *bbox_s;
 #endif
 
         bbox_override = extent_.from_string(*bbox_s);
@@ -156,12 +154,10 @@ void gdal_datasource::bind() const
     }
 
 #ifdef MAPNIK_LOG
-    if (log_enabled_)
-    {
-        mapnik::log() << "gdal_datasource Geotransform=" << tr[0] << "," << tr[1] << ","
-                      << tr[2] << "," << tr[3] << ","
-                      << tr[4] << "," << tr[5];
-    }
+    MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource Geotransform="
+                           << tr[0] << "," << tr[1] << ","
+                           << tr[2] << "," << tr[3] << ","
+                           << tr[4] << "," << tr[5];
 #endif
 
     // TODO - We should throw for true non-north up images, but the check
@@ -198,11 +194,8 @@ void gdal_datasource::bind() const
     GDALClose(dataset);
 
 #ifdef MAPNIK_LOG
-    if (log_enabled_)
-    {
-        mapnik::log() << "gdal_datasource: Raster Size=" << width_ << "," << height_;
-        mapnik::log() << "gdal_datasource: Raster Extent=" << extent_;
-    }
+    MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource: Raster Size=" << width_ << "," << height_;
+    MAPNIK_LOG_DEBUG(gdal) << "gdal_datasource: Raster Extent=" << extent_;
 #endif
 
     is_bound_ = true;
diff --git a/plugins/input/gdal/gdal_featureset.cpp b/plugins/input/gdal/gdal_featureset.cpp
index 18c5fdcaa..212126ca2 100644
--- a/plugins/input/gdal/gdal_featureset.cpp
+++ b/plugins/input/gdal/gdal_featureset.cpp
@@ -77,7 +77,7 @@ gdal_featureset::gdal_featureset(GDALDataset& dataset,
 gdal_featureset::~gdal_featureset()
 {
 #ifdef MAPNIK_LOG
-    mapnik::log() << "gdal_featureset: Closing Dataset=" << &dataset_;
+    MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Closing Dataset=" << &dataset_;
 #endif
 
     GDALClose(&dataset_);
@@ -90,7 +90,7 @@ feature_ptr gdal_featureset::next()
         first_ = false;
 
 #ifdef MAPNIK_LOG
-        mapnik::log() << "gdal_featureset: Next feature in Dataset=" << &dataset_;
+        MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Next feature in Dataset=" << &dataset_;
 #endif
 
         query *q = boost::get<query>(&gquery_);
@@ -122,13 +122,13 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
     GDALRasterBand * grey = 0;
 
     /*
+#ifdef MAPNIK_DEBUG
       double tr[6];
       dataset_.GetGeoTransform(tr);
 
-      double dx = tr[1];
-      double dy = tr[5];
-#ifdef MAPNIK_DEBUG
-      mapnik::log() << "gdal_featureset: dx_=" << dx_ << " dx=" << dx << " dy_=" << dy_ << "dy=" << dy;
+      const double dx = tr[1];
+      const double dy = tr[5];
+      MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: dx_=" << dx_ << " dx=" << dx << " dy_=" << dy_ << "dy=" << dy;
 #endif
     */
 
@@ -189,10 +189,10 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
     intersect = t.backward(feature_raster_extent);
 
 #ifdef MAPNIK_LOG
-    mapnik::log() << "gdal_featureset: Raster extent=" << raster_extent_;
-    mapnik::log() << "gdal_featureset: View extent=" << intersect;
-    mapnik::log() << "gdal_featureset: Query resolution=" << boost::get<0>(q.resolution()) << "," << boost::get<1>(q.resolution());
-    mapnik::log() << boost::format("gdal_featureset: StartX=%d StartY=%d Width=%d Height=%d") % x_off % y_off % width % height;
+    MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Raster extent=" << raster_extent_;
+    MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: View extent=" << intersect;
+    MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Query resolution=" << boost::get<0>(q.resolution()) << "," << boost::get<1>(q.resolution());
+    MAPNIK_LOG_DEBUG(gdal) << boost::format("gdal_featureset: StartX=%d StartY=%d Width=%d Height=%d") % x_off % y_off % width % height;
 #endif
 
     if (width > 0 && height > 0)
@@ -209,7 +209,7 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
             im_height *= filter_factor_;
 
 #ifdef MAPNIK_LOG
-            mapnik::log() << "gdal_featureset: Applying layer filter_factor=" << filter_factor_;
+            MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Applying layer filter_factor=" << filter_factor_;
 #endif
         }
         // otherwise respect symbolizer level factor applied to query, default of 1.0
@@ -234,8 +234,8 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
             image.set(0xffffffff);
 
 #ifdef MAPNIK_LOG
-            mapnik::log() << "gdal_featureset: Image Size=(" << im_width << "," << im_height << ")";
-            mapnik::log() << "gdal_featureset: Reading band=" << band_;
+            MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Image Size=(" << im_width << "," << im_height << ")";
+            MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Reading band=" << band_;
 #endif
             typedef std::vector<int,int> pallete;
 
@@ -285,38 +285,38 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
                     case GCI_RedBand:
                         red = band;
 #ifdef MAPNIK_LOG
-                        mapnik::log() << "gdal_featureset: Found red band";
+                        MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found red band";
 #endif
                         break;
                     case GCI_GreenBand:
                         green = band;
 #ifdef MAPNIK_LOG
-                        mapnik::log() << "gdal_featureset: Found green band";
+                        MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found green band";
 #endif
                         break;
                     case GCI_BlueBand:
                         blue = band;
 #ifdef MAPNIK_LOG
-                        mapnik::log() << "gdal_featureset: Found blue band";
+                        MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found blue band";
 #endif
                         break;
                     case GCI_AlphaBand:
                         alpha = band;
 #ifdef MAPNIK_LOG
-                        mapnik::log() << "gdal_featureset: Found alpha band";
+                        MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found alpha band";
 #endif
                         break;
                     case GCI_GrayIndex:
                         grey = band;
 #ifdef MAPNIK_LOG
-                        mapnik::log() << "gdal_featureset: Found gray band";
+                        MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found gray band";
 #endif
                         break;
                     case GCI_PaletteIndex:
                     {
                         grey = band;
 #ifdef MAPNIK_LOG
-                        mapnik::log() << "gdal_featureset: Found gray band, and colortable...";
+                        MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found gray band, and colortable...";
 #endif
                         GDALColorTable *color_table = band->GetColorTable();
 
@@ -324,14 +324,14 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
                         {
                             int count = color_table->GetColorEntryCount();
 #ifdef MAPNIK_LOG
-                            mapnik::log() << "gdal_featureset: Color Table count=" << count;
+                            MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Color Table count=" << count;
 #endif
                             for (int j = 0; j < count; j++)
                             {
                                 const GDALColorEntry *ce = color_table->GetColorEntry (j);
                                 if (! ce) continue;
 #ifdef MAPNIK_LOG
-                                mapnik::log() << "gdal_featureset: Color entry RGB=" << ce->c1 << "," <<ce->c2 << "," << ce->c3;
+                                MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Color entry RGB=" << ce->c1 << "," <<ce->c2 << "," << ce->c3;
 #endif
                             }
                         }
@@ -339,13 +339,13 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
                     }
                     case GCI_Undefined:
 #ifdef MAPNIK_LOG
-                        mapnik::log() << "gdal_featureset: Found undefined band (assumming gray band)";
+                        MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Found undefined band (assumming gray band)";
 #endif
                         grey = band;
                         break;
                     default:
 #ifdef MAPNIK_LOG
-                        mapnik::log() << "gdal_featureset: Band type unknown!";
+                        MAPNIK_LOG_WARN(gdal) << "gdal_featureset: Band type unknown!";
 #endif
                         break;
                     }
@@ -354,7 +354,7 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
                 if (red && green && blue)
                 {
 #ifdef MAPNIK_LOG
-                    mapnik::log() << "gdal_featureset: Processing rgb bands...";
+                    MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Processing rgb bands...";
 #endif
                     int hasNoData(0);
                     double nodata(0);
@@ -407,7 +407,7 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
                 else if (grey)
                 {
 #ifdef MAPNIK_LOG
-                    mapnik::log() << "gdal_featureset: Processing gray band...";
+                    MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Processing gray band...";
 #endif
                     int hasNoData(0);
                     double nodata(0);
@@ -425,7 +425,7 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
                     if (hasNoData && ! color_table)
                     {
 #ifdef MAPNIK_LOG
-                        mapnik::log() << "gdal_featureset: No data value for layer=" << nodata;
+                        MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: No data value for layer=" << nodata;
 #endif
                         feature->put("NODATA",nodata);
                         // first read the data in and create an alpha channel from the nodata values
@@ -459,7 +459,7 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
                     if (color_table)
                     {
 #ifdef MAPNIK_LOG
-                        mapnik::log() << "gdal_featureset: Loading colour table...";
+                        MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: Loading colour table...";
 #endif
                         unsigned nodata_value = static_cast<unsigned>(nodata);
                         if (hasNoData)
@@ -499,7 +499,7 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
                 if (alpha)
                 {
 #ifdef MAPNIK_LOG
-                    mapnik::log() << "gdal_featureset: processing alpha band...";
+                    MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: processing alpha band...";
 #endif
                     alpha->RasterIO(GF_Read, x_off, y_off, width, height, image.getBytes() + 3,
                                     image.width(), image.height(), GDT_Byte, 4, 4 * image.width());
@@ -536,8 +536,8 @@ feature_ptr gdal_featureset::get_feature_at_point(mapnik::coord2d const& pt)
         if (x < raster_xsize && y < raster_ysize)
         {
 #ifdef MAPNIK_LOG
-            mapnik::log() << boost::format("gdal_featureset: pt.x=%f pt.y=%f") % pt.x % pt.y;
-            mapnik::log() << boost::format("gdal_featureset: x=%f y=%f") % x % y;
+            MAPNIK_LOG_DEBUG(gdal) << boost::format("gdal_featureset: pt.x=%f pt.y=%f") % pt.x % pt.y;
+            MAPNIK_LOG_DEBUG(gdal) << boost::format("gdal_featureset: x=%f y=%f") % x % y;
 #endif
             GDALRasterBand* band = dataset_.GetRasterBand(band_);
             int hasNoData;
@@ -566,18 +566,18 @@ void gdal_featureset::get_overview_meta(GDALRasterBand* band)
     int band_overviews = band->GetOverviewCount();
     if (band_overviews > 0)
     {
-        mapnik::log() << "gdal_featureset: " << band_overviews << " overviews found!";
+        MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: " << band_overviews << " overviews found!";
 
         for (int b = 0; b < band_overviews; b++)
         {
             GDALRasterBand * overview = band->GetOverview(b);
-            mapnik::log() << boost::format("gdal_featureset: Overview=%d Width=%d Height=%d")
+            MAPNIK_LOG_DEBUG(gdal) << boost::format("gdal_featureset: Overview=%d Width=%d Height=%d")
                 % b % overview->GetXSize() % overview->GetYSize();
         }
     }
     else
     {
-        mapnik::log() << "gdal_featureset: No overviews found!";
+        MAPNIK_LOG_DEBUG(gdal) << "gdal_featureset: No overviews found!";
     }
 
     int bsx,bsy;
@@ -585,7 +585,7 @@ void gdal_featureset::get_overview_meta(GDALRasterBand* band)
     band->GetBlockSize(&bsx, &bsy);
     scale = band->GetScale();
 
-    mapnik::log() << boost::format("gdal_featureset: Block=%dx%d Scale=%f Type=%s Color=%s") % bsx % bsy % scale
+    MAPNIK_LOG_DEBUG(gdal) << boost::format("gdal_featureset: Block=%dx%d Scale=%f Type=%s Color=%s") % bsx % bsy % scale
         % GDALGetDataTypeName(band->GetRasterDataType())
         % GDALGetColorInterpretationName(band->GetColorInterpretation());
 }
diff --git a/plugins/input/gdal/gdal_featureset.hpp b/plugins/input/gdal/gdal_featureset.hpp
index e0d8e533d..a9912e70e 100644
--- a/plugins/input/gdal/gdal_featureset.hpp
+++ b/plugins/input/gdal/gdal_featureset.hpp
@@ -52,12 +52,15 @@ public:
                     boost::optional<double> const& nodata);
     virtual ~gdal_featureset();
     mapnik::feature_ptr next();
+
 private:
     mapnik::feature_ptr get_feature(mapnik::query const& q);
     mapnik::feature_ptr get_feature_at_point(mapnik::coord2d const& p);
+
 #ifdef MAPNIK_LOG
     void get_overview_meta(GDALRasterBand * band);
 #endif
+
     GDALDataset & dataset_;
     mapnik::context_ptr ctx_;
     int band_;
diff --git a/plugins/input/geos/geos_datasource.cpp b/plugins/input/geos/geos_datasource.cpp
index 58e02cd7a..62e0c5159 100644
--- a/plugins/input/geos/geos_datasource.cpp
+++ b/plugins/input/geos/geos_datasource.cpp
@@ -100,8 +100,6 @@ geos_datasource::geos_datasource(parameters const& params, bool bind)
       geometry_data_name_("name"),
       geometry_id_(1)
 {
-    log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
-
     boost::optional<std::string> geometry = params.get<std::string>("wkt");
     if (! geometry) throw datasource_exception("missing <wkt> parameter");
     geometry_string_ = *geometry;
@@ -162,7 +160,7 @@ void geos_datasource::bind() const
 #endif
 
 #ifdef MAPNIK_LOG
-        if (log_enabled_) mapnik::log() << "geos_datasource: Initializing extent from geometry";
+        MAPNIK_LOG_DEBUG(geos) << "geos_datasource: Initializing extent from geometry";
 #endif
 
         if (GEOSGeomTypeId(*geometry_) == GEOS_POINT)
@@ -185,12 +183,9 @@ void geos_datasource::bind() const
             if (*envelope != NULL && GEOSisValid(*envelope))
             {
 #ifdef MAPNIK_LOG
-                if (log_enabled_)
-                {
-                    char* wkt = GEOSGeomToWKT(*envelope);
-                    mapnik::log() << "geos_datasource: Getting coord sequence from=" << wkt;
-                    GEOSFree(wkt);
-                }
+                char* wkt = GEOSGeomToWKT(*envelope);
+                MAPNIK_LOG_DEBUG(geos) << "geos_datasource: Getting coord sequence from=" << wkt;
+                GEOSFree(wkt);
 #endif
 
                 const GEOSGeometry* exterior = GEOSGetExteriorRing(*envelope);
@@ -200,7 +195,7 @@ void geos_datasource::bind() const
                     if (cs != NULL)
                     {
 #ifdef MAPNIK_LOG
-                        if (log_enabled_) mapnik::log() << "geos_datasource: Iterating boundary points";
+                        MAPNIK_LOG_DEBUG(geos) << "geos_datasource: Iterating boundary points";
 #endif
 
                         double x, y;
@@ -319,7 +314,7 @@ featureset_ptr geos_datasource::features(query const& q) const
       << "))";
 
 #ifdef MAPNIK_LOG
-    if (log_enabled_) mapnik::log() << "geos_datasource: Using extent=" << s.str();
+    MAPNIK_LOG_DEBUG(geos) << "geos_datasource: Using extent=" << s.str();
 #endif
 
     return boost::make_shared<geos_featureset>(*geometry_,
@@ -342,7 +337,7 @@ featureset_ptr geos_datasource::features_at_point(coord2d const& pt) const
     s << "POINT(" << pt.x << " " << pt.y << ")";
 
 #ifdef MAPNIK_LOG
-    if (log_enabled_) mapnik::log() << "geos_datasource: Using point=" << s.str();
+    MAPNIK_LOG_DEBUG(geos) << "geos_datasource: Using point=" << s.str();
 #endif
 
     return boost::make_shared<geos_featureset>(*geometry_,
diff --git a/plugins/input/geos/geos_featureset.cpp b/plugins/input/geos/geos_featureset.cpp
index 5d9ad33dc..c2da0e730 100644
--- a/plugins/input/geos/geos_featureset.cpp
+++ b/plugins/input/geos/geos_featureset.cpp
@@ -106,7 +106,7 @@ feature_ptr geos_featureset::next()
 
                 default:
 #ifdef MAPNIK_LOG
-                    mapnik::log() << "geos_featureset: Unknown extent geometry_type=" << type;
+                    MAPNIK_LOG_DEBUG(geos) << "geos_featureset: Unknown extent geometry_type=" << type;
 #endif
                     break;
                 }
diff --git a/plugins/input/kismet/kismet_datasource.cpp b/plugins/input/kismet/kismet_datasource.cpp
index a2051de95..a061cac84 100644
--- a/plugins/input/kismet/kismet_datasource.cpp
+++ b/plugins/input/kismet/kismet_datasource.cpp
@@ -79,8 +79,6 @@ kismet_datasource::kismet_datasource(parameters const& params, bool bind)
       srs_("+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs"),
       desc_(*params.get<std::string>("type"), *params.get<std::string>("encoding","utf-8"))
 {
-    log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
-
     boost::optional<std::string> host = params_.get<std::string>("host");
     if (host)
     {
@@ -159,7 +157,7 @@ featureset_ptr kismet_datasource::features(query const& q) const
     if (! is_bound_) bind();
 
 #ifdef MAPNIK_LOG
-    // mapnik::log() << "kismet_datasource::features()";
+    // MAPNIK_LOG_DEBUG(kismet) << "kismet_datasource::features()";
 #endif
 
     // TODO: use box2d to filter bbox before adding to featureset_ptr
@@ -179,7 +177,7 @@ featureset_ptr kismet_datasource::features_at_point(coord2d const& pt) const
     if (! is_bound_) bind();
 
 #ifdef MAPNIK_LOG
-    // mapnik::log() << "kismet_datasource::features_at_point()";
+    // MAPNIK_LOG_DEBUG(kismet) << "kismet_datasource::features_at_point()";
 #endif
 
     return featureset_ptr();
@@ -188,7 +186,7 @@ featureset_ptr kismet_datasource::features_at_point(coord2d const& pt) const
 void kismet_datasource::run(const std::string& ip_host, const unsigned int port)
 {
 #ifdef MAPNIK_LOG
-    if (log_enabled_) mapnik::log() << "kismet_datasource: Enter run";
+    MAPNIK_LOG_DEBUG(kismet) << "kismet_datasource: Enter run";
 #endif
 
     int sockfd, n;
@@ -209,7 +207,7 @@ void kismet_datasource::run(const std::string& ip_host, const unsigned int port)
 
     if (host == NULL)
     {
-        std::cerr << "Kismet Plugin: error while searching host" << std::endl;
+        MAPNIK_LOG_ERROR(kismet) << "Kismet Plugin: error while searching host";
         return;
     }
 
@@ -219,13 +217,13 @@ void kismet_datasource::run(const std::string& ip_host, const unsigned int port)
 
     if ((sockfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)
     {
-        std::cerr << "Kismet Plugin: error while creating socket" << std::endl;
+        MAPNIK_LOG_ERROR(kismet) << "Kismet Plugin: error while creating socket";
         return;
     }
 
     if (connect(sockfd, (struct sockaddr*) &sock_addr, sizeof(sock_addr)))
     {
-        std::cerr << "Kismet Plugin: Error while connecting" << std::endl;
+        MAPNIK_LOG_ERROR(kismet) << "Kismet Plugin: Error while connecting";
         return;
     }
 
@@ -233,7 +231,7 @@ void kismet_datasource::run(const std::string& ip_host, const unsigned int port)
 
     if (write(sockfd, command.c_str(), command.length()) != (signed)command.length())
     {
-        std::cerr << "Kismet Plugin: Error sending command to " << ip_host << std::endl;
+        MAPNIK_LOG_ERROR(kismet) << "Kismet Plugin: Error sending command to " << ip_host;
 
         close(sockfd);
         return;
@@ -255,7 +253,7 @@ void kismet_datasource::run(const std::string& ip_host, const unsigned int port)
         std::string bufferObj(buffer); // TCP data send from kismet_server as STL string
 
 #ifdef MAPNIK_LOG
-        if (log_enabled_) mapnik::log() << "kismet_datasource: buffer_obj=" << bufferObj;
+        MAPNIK_LOG_DEBUG(kismet) << "kismet_datasource: buffer_obj=" << bufferObj;
 #endif
 
         std::string::size_type found = 0;
@@ -269,7 +267,7 @@ void kismet_datasource::run(const std::string& ip_host, const unsigned int port)
                 kismet_line.assign(bufferObj, search_start, found - search_start);
 
 #ifdef MAPNIK_LOG
-                if (log_enabled_) mapnik::log() << "kismet_datasource: line=" << kismet_line;
+                MAPNIK_LOG_DEBUG(kismet) << "kismet_datasource: line=" << kismet_line;
 #endif
 
                 int param_number = 5; // the number of parameters to parse
@@ -284,11 +282,11 @@ void kismet_datasource::run(const std::string& ip_host, const unsigned int port)
                             &bestlon) == param_number)
                 {
 #ifdef MAPNIK_LOG
-                    if (log_enabled_)
-                    {
-                        mapnik::log() << "kismet_datasource: ssid=" << ssid << ", bssid=" << bssid
-                                      << ", crypt=" << crypt << ", bestlat=" << bestlat << ", bestlon=" << bestlon;
-                    }
+                    MAPNIK_LOG_DEBUG(kismet) << "kismet_datasource: ssid=" << ssid
+                                             << ", bssid=" << bssid
+                                             << ", crypt=" << crypt
+                                             << ", bestlat=" << bestlat
+                                             << ", bestlon=" << bestlon;
 #endif
 
                     kismet_network_data knd(ssid, bssid, bestlat, bestlon, crypt);
@@ -316,13 +314,13 @@ void kismet_datasource::run(const std::string& ip_host, const unsigned int port)
 
     if (n < 0)
     {
-        std::cerr << "Kismet Plugin: error while reading from socket" << std::endl;
+        MAPNIK_LOG_ERROR(kismet) << "Kismet Plugin: error while reading from socket";
     }
 
     close(sockfd);
 
 #ifdef MAPNIK_LOG
-    if (log_enabled_) mapnik::log() << "kismet_datasource: Exit run";
+    MAPNIK_LOG_DEBUG(kismet) << "kismet_datasource: Exit run";
 #endif
 }
 
diff --git a/plugins/input/kismet/kismet_datasource.hpp b/plugins/input/kismet/kismet_datasource.hpp
index 308246dde..1d49475ca 100644
--- a/plugins/input/kismet/kismet_datasource.hpp
+++ b/plugins/input/kismet/kismet_datasource.hpp
@@ -23,7 +23,7 @@
 #ifndef KISMET_DATASOURCE_HPP
 #define KISMET_DATASOURCE_HPP
 
-// STL
+// stl
 #include <list>
 
 // mapnik
diff --git a/plugins/input/occi/occi_datasource.cpp b/plugins/input/occi/occi_datasource.cpp
index 1aba3cdcc..dff242a6b 100644
--- a/plugins/input/occi/occi_datasource.cpp
+++ b/plugins/input/occi/occi_datasource.cpp
@@ -82,8 +82,6 @@ occi_datasource::occi_datasource(parameters const& params, bool bind)
       pool_(0),
       conn_(0)
 {
-    log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
-
     if (! params_.get<std::string>("user")) throw datasource_exception("OCCI Plugin: no <user> specified");
     if (! params_.get<std::string>("password")) throw datasource_exception("OCCI Plugin: no <password> specified");
     if (! params_.get<std::string>("host")) throw datasource_exception("OCCI Plugin: no <host> string specified");
@@ -206,7 +204,7 @@ void occi_datasource::bind() const
         }
 
 #ifdef MAPNIK_LOG
-        if (log_enabled_) mapnik::log() << "occi_datasource: " << s.str();
+        MAPNIK_LOG_DEBUG(occi) << "occi_datasource: " << s.str();
 #endif
 
         try
@@ -246,7 +244,7 @@ void occi_datasource::bind() const
         s << "SELECT " << fields_ << " FROM (" << table_name_ << ") WHERE rownum < 1";
 
 #ifdef MAPNIK_LOG
-        if (log_enabled_) mapnik::log() << "occi_datasource: " << s.str();
+        MAPNIK_LOG_DEBUG(occi) << "occi_datasource: " << s.str();
 #endif
 
         try
@@ -338,21 +336,15 @@ void occi_datasource::bind() const
                     case oracle::occi::OCCI_SQLT_BLOB:
                     case oracle::occi::OCCI_SQLT_RSET:
 #ifdef MAPNIK_LOG
-                        if (log_enabled_)
-                        {
-                            mapnik::log() << "occi_datasource: Unsupported datatype "
-                                          << occi_enums::resolve_datatype(type_oid)
-                                          << " (type_oid=" << type_oid << ")";
-                        }
+                        MAPNIK_LOG_WARN(occi) << "occi_datasource: Unsupported datatype "
+                                              << occi_enums::resolve_datatype(type_oid)
+                                              << " (type_oid=" << type_oid << ")";
 #endif
                         break;
                     default:
 #ifdef MAPNIK_LOG
-                        if (log_enabled_)
-                        {
-                            mapnik::log() << "occi_datasource: Unknown datatype "
-                                          << "(type_oid=" << type_oid << ")";
-                        }
+                        MAPNIK_LOG_WARN(occi) << "occi_datasource: Unknown datatype "
+                                              << "(type_oid=" << type_oid << ")";
 #endif
                         break;
                     }
@@ -400,7 +392,7 @@ box2d<double> occi_datasource::envelope() const
         s << " TABLE(SDO_UTIL.GETVERTICES(a.shape)) c";
 
 #ifdef MAPNIK_LOG
-        if (log_enabled_) mapnik::log() << "occi_datasource: " << s.str();
+        MAPNIK_LOG_DEBUG(occi) << "occi_datasource: " << s.str();
 #endif
 
         try
@@ -423,7 +415,7 @@ box2d<double> occi_datasource::envelope() const
                 }
                 catch (bad_lexical_cast& ex)
                 {
-                    std::cerr << "OCCI Plugin: " << ex.what() << std::endl;
+                    MAPNIK_LOG_WARN(occi) << "OCCI Plugin: " << ex.what();
                 }
             }
         }
@@ -448,7 +440,7 @@ box2d<double> occi_datasource::envelope() const
         s << " WHERE LOWER(m.table_name) = LOWER('" << table_name_ << "') AND dim.sdo_dimname = 'Y'";
 
 #ifdef MAPNIK_LOG
-        if (log_enabled_) mapnik::log() << "occi_datasource: " << s.str();
+        MAPNIK_LOG_DEBUG(occi) << "occi_datasource: " << s.str();
 #endif
 
         try
@@ -469,7 +461,7 @@ box2d<double> occi_datasource::envelope() const
                     }
                     catch (bad_lexical_cast& ex)
                     {
-                        std::cerr << "OCCI Plugin: " << ex.what() << std::endl;
+                        MAPNIK_LOG_WARN(occi) << "OCCI Plugin: " << ex.what();
                     }
                 }
 
@@ -482,7 +474,7 @@ box2d<double> occi_datasource::envelope() const
                     }
                     catch (bad_lexical_cast& ex)
                     {
-                        std::cerr << "OCCI Plugin: " << ex.what() << std::endl;
+                        MAPNIK_LOG_WARN(occi) << "OCCI Plugin: " << ex.what();
                     }
                 }
 
@@ -574,9 +566,7 @@ featureset_ptr occi_datasource::features(query const& q) const
         }
         else
         {
-#ifdef MAPNIK_LOG
-            if (log_enabled_) mapnik::log() << "occi_datasource: cannot determine where to add the spatial filter declaration";
-#endif
+            MAPNIK_LOG_WARN(occi) << "occi_datasource: cannot determine where to add the spatial filter declaration";
         }
     }
 
@@ -594,16 +584,14 @@ featureset_ptr occi_datasource::features(query const& q) const
         }
         else
         {
-#ifdef MAPNIK_LOG
-            if (log_enabled_) mapnik::log() << "occi_datasource: Cannot determine where to add the row limit declaration";
-#endif
+            MAPNIK_LOG_WARN(occi) << "occi_datasource: Cannot determine where to add the row limit declaration";
         }
     }
 
     s << query;
 
 #ifdef MAPNIK_LOG
-    if (log_enabled_) mapnik::log() << "occi_datasource: " << s.str();
+    MAPNIK_LOG_DEBUG(occi) << "occi_datasource: " << s.str();
 #endif
 
     return boost::make_shared<occi_featureset>(pool_,
@@ -668,9 +656,7 @@ featureset_ptr occi_datasource::features_at_point(coord2d const& pt) const
         }
         else
         {
-#ifdef MAPNIK_LOG
-            if (log_enabled_) mapnik::log() << "occi_datasource: Cannot determine where to add the spatial filter declaration";
-#endif
+            MAPNIK_LOG_WARN(occi) << "occi_datasource: Cannot determine where to add the spatial filter declaration";
         }
     }
 
@@ -688,16 +674,14 @@ featureset_ptr occi_datasource::features_at_point(coord2d const& pt) const
         }
         else
         {
-#ifdef MAPNIK_LOG
-            if (log_enabled_) mapnik::log() << "occi_datasource: Cannot determine where to add the row limit declaration";
-#endif
+            MAPNIK_LOG_WARN(occi) << "occi_datasource: Cannot determine where to add the row limit declaration";
         }
     }
 
     s << query;
 
 #ifdef MAPNIK_LOG
-    if (log_enabled_) mapnik::log() << "occi_datasource: " << s.str();
+    MAPNIK_LOG_DEBUG(occi) << "occi_datasource: " << s.str();
 #endif
 
     return boost::make_shared<occi_featureset>(pool_,
diff --git a/plugins/input/occi/occi_featureset.cpp b/plugins/input/occi/occi_featureset.cpp
index 55e4abc6f..f0c21700b 100644
--- a/plugins/input/occi/occi_featureset.cpp
+++ b/plugins/input/occi/occi_featureset.cpp
@@ -84,7 +84,7 @@ occi_featureset::occi_featureset(StatelessConnectionPool* pool,
     }
     catch (SQLException &ex)
     {
-        std::cerr << "OCCI Plugin: error processing " << sqlstring << " : " << ex.getMessage() << std::endl;
+        MAPNIK_LOG_ERROR(occi) << "OCCI Plugin: error processing " << sqlstring << " : " << ex.getMessage();
     }
 }
 
@@ -206,17 +206,17 @@ feature_ptr occi_featureset::next()
             case oracle::occi::OCCI_SQLT_RSET:
                 {
 #ifdef MAPNIK_LOG
-                    mapnik::log() << "occi_featureset: Unsupported datatype "
-                                  << occi_enums::resolve_datatype(type_oid)
-                                  << " (type_oid=" << type_oid << ")";
+                    MAPNIK_LOG_WARN(occi) << "occi_featureset: Unsupported datatype "
+                                          << occi_enums::resolve_datatype(type_oid)
+                                          << " (type_oid=" << type_oid << ")";
 #endif
                     break;
                 }
             default: // shouldn't get here
                 {
 #ifdef MAPNIK_LOG
-                    mapnik::log() << "occi_featureset: Unknown datatype "
-                                  << "(type_oid=" << type_oid << ")";
+                    MAPNIK_LOG_WARN(occi) << "occi_featureset: Unknown datatype "
+                                          << "(type_oid=" << type_oid << ")";
 #endif
                     break;
                 }
@@ -360,9 +360,9 @@ void occi_featureset::convert_geometry(SDOGeometry* geom, feature_ptr feature)
     default:
     {
 #ifdef MAPNIK_LOG
-        mapnik::log() << "occi_featureset: Unknown oracle enum "
-                      << occi_enums::resolve_gtype(geomtype)
-                      << "(gtype=" << gtype << ")";
+        MAPNIK_LOG_WARN(occi) << "occi_featureset: Unknown oracle enum "
+                              << occi_enums::resolve_gtype(geomtype)
+                              << "(gtype=" << gtype << ")";
 #endif
     }
     break;
diff --git a/plugins/input/occi/occi_types.hpp b/plugins/input/occi/occi_types.hpp
index 30506a2ea..fc7992d9c 100644
--- a/plugins/input/occi/occi_types.hpp
+++ b/plugins/input/occi/occi_types.hpp
@@ -89,7 +89,7 @@ public:
         if (env_ == 0)
         {
 #ifdef MAPNIK_LOG
-            mapnik::log() << "occi_environment: constructor";
+            MAPNIK_LOG_DEBUG(occi) << "occi_environment: constructor";
 #endif
 
             const int mode = oracle::occi::Environment::OBJECT
@@ -113,7 +113,7 @@ private:
         if (env_)
         {
 #ifdef MAPNIK_LOG
-            mapnik::log() << "occi_environment: destructor";
+            MAPNIK_LOG_DEBUG(occi) << "occi_environment: destructor";
 #endif
 
             oracle::occi::Environment::terminateEnvironment(env_);
@@ -164,6 +164,10 @@ public:
     {
         close_query(false);
 
+#ifdef MAPNIK_LOG
+        MAPNIK_LOG_DEBUG(occi) << "occi_connection_ptr: " << s;
+#endif
+
         stmt_ = conn_->createStatement(s);
 
         if (prefetch > 0)
diff --git a/plugins/input/ogr/ogr_converter.cpp b/plugins/input/ogr/ogr_converter.cpp
index a372e1fce..294768474 100644
--- a/plugins/input/ogr/ogr_converter.cpp
+++ b/plugins/input/ogr/ogr_converter.cpp
@@ -71,8 +71,8 @@ void ogr_converter::convert_geometry(OGRGeometry* geom, feature_ptr feature)
     default:
         {
 #ifdef MAPNIK_LOG
-            mapnik::log() << "ogr_converter: unknown <ogr> geometry_type="
-                          << wkbFlatten(geom->getGeometryType());
+            MAPNIK_LOG_WARN(ogr) << "ogr_converter: unknown <ogr> geometry_type="
+                                 << wkbFlatten(geom->getGeometryType());
 #endif
         }
         break;
diff --git a/plugins/input/ogr/ogr_datasource.cpp b/plugins/input/ogr/ogr_datasource.cpp
index 867c7dd07..41182968b 100644
--- a/plugins/input/ogr/ogr_datasource.cpp
+++ b/plugins/input/ogr/ogr_datasource.cpp
@@ -65,8 +65,6 @@ ogr_datasource::ogr_datasource(parameters const& params, bool bind)
       desc_(*params_.get<std::string>("type"), *params_.get<std::string>("encoding", "utf-8")),
       indexed_(false)
 {
-    log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
-
     boost::optional<std::string> file = params.get<std::string>("file");
     boost::optional<std::string> string = params.get<std::string>("string");
     if (! file && ! string)
@@ -276,11 +274,8 @@ void ogr_datasource::bind() const
     // TODO - enable this warning once the ogrindex tool is a bit more stable/mature
     else
     {
-        if (log_enabled_)
-        {
-            mapnik::log() << "ogr_datasource: no ogrindex file found for " << dataset_name_
-                          << ", use the 'ogrindex' program to build an index for faster rendering";
-        }
+        MAPNIK_LOG_DEBUG(ogr) << "ogr_datasource: no ogrindex file found for " << dataset_name_
+                              << ", use the 'ogrindex' program to build an index for faster rendering";
     }
 #endif
 #endif // MAPNIK_LOG
@@ -325,7 +320,7 @@ void ogr_datasource::bind() const
             case OFTStringList:
             case OFTWideStringList: // deprecated !
 #ifdef MAPNIK_LOG
-                if (log_enabled_) mapnik::log() << "ogr_datasource: Unhandled type_oid=" << type_oid;
+                MAPNIK_LOG_WARN(ogr) << "ogr_datasource: Unhandled type_oid=" << type_oid;
 #endif
                 break;
 
@@ -333,7 +328,7 @@ void ogr_datasource::bind() const
             case OFTTime:
             case OFTDateTime: // unhandled !
 #ifdef MAPNIK_LOG
-                if (log_enabled_) mapnik::log() << "ogr_datasource: Unhandled type_oid=" << type_oid;
+                MAPNIK_LOG_WARN(ogr) << "ogr_datasource: Unhandled type_oid=" << type_oid;
 #endif
                 desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::Object));
                 break;
@@ -514,8 +509,7 @@ featureset_ptr ogr_datasource::features(query const& q) const
                                                                           *layer,
                                                                           filter,
                                                                           index_name_,
-                                                                          desc_.get_encoding()
-                                      ));
+                                                                          desc_.get_encoding()));
         }
         else
         {
@@ -523,8 +517,7 @@ featureset_ptr ogr_datasource::features(query const& q) const
                                                       *dataset_,
                                                       *layer,
                                                       q.get_bbox(),
-                                                      desc_.get_encoding()
-                                      ));
+                                                      desc_.get_encoding()));
         }
     }
 
diff --git a/plugins/input/ogr/ogr_featureset.cpp b/plugins/input/ogr/ogr_featureset.cpp
index daea475ef..d1f679013 100644
--- a/plugins/input/ogr/ogr_featureset.cpp
+++ b/plugins/input/ogr/ogr_featureset.cpp
@@ -106,7 +106,7 @@ feature_ptr ogr_featureset::next()
 #ifdef MAPNIK_LOG
         else
         {
-            mapnik::log() << "ogr_featureset: Feature with null geometry=" << (*feat)->GetFID();
+            MAPNIK_LOG_DEBUG(ogr) << "ogr_featureset: Feature with null geometry=" << (*feat)->GetFID();
         }
 #endif
         ++count_;
@@ -146,7 +146,7 @@ feature_ptr ogr_featureset::next()
             case OFTWideStringList: // deprecated !
             {
 #ifdef MAPNIK_LOG
-                mapnik::log() << "ogr_featureset: Unhandled type_oid=" << type_oid;
+                MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unhandled type_oid=" << type_oid;
 #endif
                 break;
             }
@@ -154,7 +154,7 @@ feature_ptr ogr_featureset::next()
             case OFTBinary:
             {
 #ifdef MAPNIK_LOG
-                mapnik::log() << "ogr_featureset: Unhandled type_oid=" << type_oid;
+                MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unhandled type_oid=" << type_oid;
 #endif
                 //feature->put(name,feat->GetFieldAsBinary (i, size));
                 break;
@@ -165,7 +165,7 @@ feature_ptr ogr_featureset::next()
             case OFTDateTime:       // unhandled !
             {
 #ifdef MAPNIK_LOG
-                mapnik::log() << "ogr_featureset: Unhandled type_oid=" << type_oid;
+                MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unhandled type_oid=" << type_oid;
 #endif
                 break;
             }
@@ -173,7 +173,7 @@ feature_ptr ogr_featureset::next()
             default: // unknown
             {
 #ifdef MAPNIK_LOG
-                mapnik::log() << "ogr_featureset: Unknown type_oid=" << type_oid;
+                MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unknown type_oid=" << type_oid;
 #endif
                 break;
             }
@@ -183,7 +183,7 @@ feature_ptr ogr_featureset::next()
     }
 
 #ifdef MAPNIK_LOG
-    mapnik::log() << "ogr_featureset: " << count_ << " features";
+    MAPNIK_LOG_DEBUG(ogr) << "ogr_featureset: " << count_ << " features";
 #endif
 
     return feature_ptr();
diff --git a/plugins/input/ogr/ogr_index.hpp b/plugins/input/ogr/ogr_index.hpp
index f4e2e7417..ff793c622 100644
--- a/plugins/input/ogr/ogr_index.hpp
+++ b/plugins/input/ogr/ogr_index.hpp
@@ -23,9 +23,10 @@
 #ifndef OGR_INDEX_HH
 #define OGR_INDEX_HH
 
-// st
+// stl
 #include <fstream>
 #include <vector>
+
 // mapnik
 #include <mapnik/box2d.hpp>
 #include <mapnik/query.hpp>
diff --git a/plugins/input/ogr/ogr_index_featureset.cpp b/plugins/input/ogr/ogr_index_featureset.cpp
index 1821e42de..b0410878a 100644
--- a/plugins/input/ogr/ogr_index_featureset.cpp
+++ b/plugins/input/ogr/ogr_index_featureset.cpp
@@ -77,7 +77,7 @@ ogr_index_featureset<filterT>::ogr_index_featureset(mapnik::context_ptr const &
     std::sort(ids_.begin(),ids_.end());
 
 #ifdef MAPNIK_LOG
-    mapnik::log() << "ogr_index_featureset: Query size=" << ids_.size();
+    MAPNIK_LOG_DEBUG(ogr) << "ogr_index_featureset: Query size=" << ids_.size();
 #endif
 
     itr_ = ids_.begin();
@@ -113,7 +113,7 @@ feature_ptr ogr_index_featureset<filterT>::next()
 #ifdef MAPNIK_LOG
             else
             {
-                mapnik::log() << "ogr_index_featureset: Feature with null geometry=" << (*feat)->GetFID();
+                MAPNIK_LOG_DEBUG(ogr) << "ogr_index_featureset: Feature with null geometry=" << (*feat)->GetFID();
             }
 #endif
 
@@ -152,7 +152,7 @@ feature_ptr ogr_index_featureset<filterT>::next()
                 case OFTWideStringList: // deprecated !
                 {
 #ifdef MAPNIK_LOG
-                    mapnik::log() << "ogr_index_featureset: Unhandled type_oid=" << type_oid;
+                    MAPNIK_LOG_WARN(ogr) << "ogr_index_featureset: Unhandled type_oid=" << type_oid;
 #endif
                     break;
                 }
@@ -160,7 +160,7 @@ feature_ptr ogr_index_featureset<filterT>::next()
                 case OFTBinary:
                 {
 #ifdef MAPNIK_LOG
-                    mapnik::log() << "ogr_index_featureset: Unhandled type_oid=" << type_oid;
+                    MAPNIK_LOG_WARN(ogr) << "ogr_index_featureset: Unhandled type_oid=" << type_oid;
 #endif
                     //feature->put(name,feat->GetFieldAsBinary (i, size));
                     break;
@@ -171,7 +171,7 @@ feature_ptr ogr_index_featureset<filterT>::next()
                 case OFTDateTime:       // unhandled !
                 {
 #ifdef MAPNIK_LOG
-                    mapnik::log() << "ogr_index_featureset: Unhandled type_oid=" << type_oid;
+                    MAPNIK_LOG_WARN(ogr) << "ogr_index_featureset: Unhandled type_oid=" << type_oid;
 #endif
                     break;
                 }
diff --git a/plugins/input/ogr/ogr_index_featureset.hpp b/plugins/input/ogr/ogr_index_featureset.hpp
index 3238bd139..cde9c68c5 100644
--- a/plugins/input/ogr/ogr_index_featureset.hpp
+++ b/plugins/input/ogr/ogr_index_featureset.hpp
@@ -52,7 +52,6 @@ private:
     std::vector<int>::iterator itr_;
     boost::scoped_ptr<mapnik::transcoder> tr_;
     const char* fidcolumn_;
-
 };
 
 #endif // OGR_INDEX_FEATURESET_HPP
diff --git a/plugins/input/ogr/ogr_layer_ptr.hpp b/plugins/input/ogr/ogr_layer_ptr.hpp
index 7c9ea6151..1a3d580b4 100644
--- a/plugins/input/ogr/ogr_layer_ptr.hpp
+++ b/plugins/input/ogr/ogr_layer_ptr.hpp
@@ -79,7 +79,7 @@ public:
             is_valid_ = true;
 
 #ifdef MAPNIK_LOG
-            mapnik::log() << "ogr_layer_ptr: layer_from_name layer=" << layer_name_;
+            MAPNIK_LOG_DEBUG(ogr) << "ogr_layer_ptr: layer_from_name layer=" << layer_name_;
 #endif
         }
 
@@ -106,7 +106,7 @@ public:
                 is_valid_ = true;
 
 #ifdef MAPNIK_LOG
-                mapnik::log() << "ogr_layer_ptr: layer_from_index layer=" << layer_name_;
+                MAPNIK_LOG_DEBUG(ogr) << "ogr_layer_ptr: layer_from_index layer=" << layer_name_;
 #endif
             }
         }
@@ -142,7 +142,7 @@ public:
                 is_valid_ = true;
 
 #ifdef MAPNIK_LOG
-                mapnik::log() << "ogr_layer_ptr: layer_from_sql layer=" << layer_name_;
+                MAPNIK_LOG_DEBUG(ogr) << "ogr_layer_ptr: layer_from_sql layer=" << layer_name_;
 #endif
             }
         }
@@ -177,11 +177,11 @@ private:
             const std::string err = CPLGetLastErrorMsg();
             if (err.size() == 0)
             {
-                mapnik::log() << "ogr_layer_ptr: Error getting layer";
+                MAPNIK_LOG_DEBUG(ogr) << "ogr_layer_ptr: Error getting layer";
             }
             else
             {
-                mapnik::log() << "ogr_layer_ptr: " << err;
+                MAPNIK_LOG_DEBUG(ogr) << "ogr_layer_ptr: " << err;
             }
         }
     }
diff --git a/plugins/input/osm/dataset_deliverer.cpp b/plugins/input/osm/dataset_deliverer.cpp
index ab1acb900..a231dc11f 100644
--- a/plugins/input/osm/dataset_deliverer.cpp
+++ b/plugins/input/osm/dataset_deliverer.cpp
@@ -84,7 +84,7 @@ osm_dataset* dataset_deliverer::load_from_url(const string& url, const string& b
     else if (bbox != last_bbox)
     {
 #ifdef MAPNIK_LOG
-        mapnik::log() << "osm_dataset_deliverer: BBoxes are different=" << last_bbox << "," << bbox;
+        MAPNIK_LOG_WARN(osm) << "osm_dataset_deliverer: BBoxes are different=" << last_bbox << "," << bbox;
 #endif
 
         // Reload the dataset
diff --git a/plugins/input/osm/osm.cpp b/plugins/input/osm/osm.cpp
index 26a998938..54ab620e5 100644
--- a/plugins/input/osm/osm.cpp
+++ b/plugins/input/osm/osm.cpp
@@ -50,7 +50,7 @@ bool osm_dataset::load_from_url(const std::string& url,
     if (parser == "libxml2")
     {
 #ifdef MAPNIK_LOG
-        mapnik::log() << "osm_dataset: load_from_url url=" << url << ",bbox=" << bbox;
+        MAPNIK_LOG_DEBUG(osm) << "osm_dataset: load_from_url url=" << url << ",bbox=" << bbox;
 #endif
 
         std::ostringstream str;
@@ -60,7 +60,7 @@ bool osm_dataset::load_from_url(const std::string& url,
         str << url << "?bbox=" << bbox;
 
 #ifdef MAPNIK_LOG
-        mapnik::log() << "osm_dataset: Full url=" << str.str();
+        MAPNIK_LOG_DEBUG(osm) << "osm_dataset: Full url=" << str.str();
 #endif
 
         CURL_LOAD_DATA* resp = grab_http_response(str.str().c_str());
@@ -72,7 +72,7 @@ bool osm_dataset::load_from_url(const std::string& url,
             blx[resp->nbytes] = '\0';
 
 #ifdef MAPNIK_LOG
-            mapnik::log() << "osm_dataset: CURL Response=" << blx;
+            MAPNIK_LOG_DEBUG(osm) << "osm_dataset: CURL Response=" << blx;
 #endif
 
             delete[] blx;
@@ -91,11 +91,11 @@ osm_dataset::~osm_dataset()
 void osm_dataset::clear()
 {
 #ifdef MAPNIK_LOG
-    mapnik::log() << "osm_dataset: Clear";
+    MAPNIK_LOG_DEBUG(osm) << "osm_dataset: Clear";
 #endif
 
 #ifdef MAPNIK_LOG
-    mapnik::log() << "osm_dataset: -- Deleting ways";
+    MAPNIK_LOG_DEBUG(osm) << "osm_dataset: -- Deleting ways";
 #endif
     for (unsigned int count = 0; count < ways.size(); ++count)
     {
@@ -105,7 +105,7 @@ void osm_dataset::clear()
     ways.clear();
 
 #ifdef MAPNIK_LOG
-    mapnik::log() << "osm_dataset: -- Deleting nodes";
+    MAPNIK_LOG_DEBUG(osm) << "osm_dataset: -- Deleting nodes";
 #endif
     for (unsigned int count = 0; count < nodes.size(); ++count)
     {
@@ -115,7 +115,7 @@ void osm_dataset::clear()
     nodes.clear();
 
 #ifdef MAPNIK_LOG
-    mapnik::log() << "osm_dataset: Clear done";
+    MAPNIK_LOG_DEBUG(osm) << "osm_dataset: Clear done";
 #endif
 }
 
diff --git a/plugins/input/osm/osm.h b/plugins/input/osm/osm.h
index 49b60f61b..ac6188663 100644
--- a/plugins/input/osm/osm.h
+++ b/plugins/input/osm/osm.h
@@ -84,14 +84,6 @@ struct osm_way : public osm_item
 
 class osm_dataset
 {
-private:
-    int next_item_mode;
-    enum { Node, Way };
-    std::vector<osm_node*>::iterator node_i;
-    std::vector<osm_way*>::iterator way_i;
-    std::vector<osm_node*> nodes;
-    std::vector<osm_way*> ways; 
-
 public:
     osm_dataset()
     {
@@ -128,6 +120,14 @@ public:
     osm_item * next_item();
     bool current_item_is_node() { return next_item_mode == Node; }
     bool current_item_is_way() { return next_item_mode == Way; }
+
+private:
+    int next_item_mode;
+    enum { Node, Way };
+    std::vector<osm_node*>::iterator node_i;
+    std::vector<osm_way*>::iterator way_i;
+    std::vector<osm_node*> nodes;
+    std::vector<osm_way*> ways;
 };
 
 #endif // OSM_H
diff --git a/plugins/input/osm/osm_datasource.cpp b/plugins/input/osm/osm_datasource.cpp
index 1884ff45b..79a19e470 100644
--- a/plugins/input/osm/osm_datasource.cpp
+++ b/plugins/input/osm/osm_datasource.cpp
@@ -58,8 +58,6 @@ osm_datasource::osm_datasource(const parameters& params, bool bind)
       type_(datasource::Vector),
       desc_(*params_.get<std::string>("type"), *params_.get<std::string>("encoding", "utf-8"))
 {
-    log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
-
     if (bind)
     {
         this->bind();
@@ -82,7 +80,7 @@ void osm_datasource::bind() const
     {
         // if we supplied a url and a bounding box, load from the url
 #ifdef MAPNIK_LOG
-        if (log_enabled_) mapnik::log() << "osm_datasource: loading_from_url url=" << url << ",bbox=" << bbox;
+        MAPNIK_LOG_DEBUG(osm) << "osm_datasource: loading_from_url url=" << url << ",bbox=" << bbox;
 #endif
 
         if ((osm_data_ = dataset_deliverer::load_from_url(url, bbox, parser)) == NULL)
diff --git a/plugins/input/osm/osm_featureset.hpp b/plugins/input/osm/osm_featureset.hpp
index dd4e9ad3a..5e50c0214 100644
--- a/plugins/input/osm/osm_featureset.hpp
+++ b/plugins/input/osm/osm_featureset.hpp
@@ -53,6 +53,7 @@ public:
                    std::string const& encoding);
     virtual ~osm_featureset();
     feature_ptr next();
+
 private:
     filterT filter_;
     box2d<double> query_ext_;
@@ -64,7 +65,7 @@ private:
     osm_dataset *dataset_;
     std::set<std::string> attribute_names_;
     mapnik::context_ptr ctx_;
-    // no copying
+
     osm_featureset(const osm_featureset&);
     const osm_featureset& operator=(const osm_featureset&);
 };
diff --git a/plugins/input/osm/osmparser.cpp b/plugins/input/osm/osmparser.cpp
index 9b83d2b79..198bea858 100644
--- a/plugins/input/osm/osmparser.cpp
+++ b/plugins/input/osm/osmparser.cpp
@@ -5,10 +5,8 @@
 #include <string>
 #include <cassert>
 
-using std::cerr;
 using std::endl;
 
-
 osm_item* osmparser::cur_item=NULL;
 long osmparser::curID=0;
 bool osmparser::in_node=false, osmparser::in_way=false;
diff --git a/plugins/input/postgis/connection.hpp b/plugins/input/postgis/connection.hpp
index 081d03db6..f0e10e0bf 100644
--- a/plugins/input/postgis/connection.hpp
+++ b/plugins/input/postgis/connection.hpp
@@ -82,7 +82,7 @@ public:
             PQfinish(conn_);
 
 #ifdef MAPNIK_LOG
-            mapnik::log() << "postgis_connection: postgresql connection closed - " << conn_;
+            MAPNIK_LOG_DEBUG(postgis) << "postgis_connection: postgresql connection closed - " << conn_;
 #endif
             closed_ = true;
         }
@@ -163,7 +163,7 @@ public:
             PQfinish(conn_);
 
 #ifdef MAPNIK_LOG
-            mapnik::log() << "postgis_connection: datasource closed, also closing connection - " << conn_;
+            MAPNIK_LOG_DEBUG(postgis) << "postgis_connection: datasource closed, also closing connection - " << conn_;
 #endif
             closed_ = true;
         }
diff --git a/plugins/input/postgis/cursorresultset.hpp b/plugins/input/postgis/cursorresultset.hpp
index 5f2f77a5d..3fac97658 100644
--- a/plugins/input/postgis/cursorresultset.hpp
+++ b/plugins/input/postgis/cursorresultset.hpp
@@ -89,7 +89,7 @@ public:
             s << "CLOSE " << cursorName_;
 
 #ifdef MAPNIK_LOG
-            mapnik::log() << "postgis_cursor_resultset: " << s.str();
+            MAPNIK_LOG_DEBUG(postgis) << "postgis_cursor_resultset: " << s.str();
 #endif
             conn_->execute(s.str());
             is_closed_ = true;
@@ -160,13 +160,13 @@ private:
         s << "FETCH FORWARD " << fetch_size_ << " FROM " << cursorName_;
 
 #ifdef MAPNIK_LOG
-        mapnik::log() << "postgis_cursor_resultset: " << s.str();
+        MAPNIK_LOG_DEBUG(postgis) << "postgis_cursor_resultset: " << s.str();
 #endif
         rs_ = conn_->executeQuery(s.str());
         is_closed_ = false;
 
 #ifdef MAPNIK_LOG
-        mapnik::log() << "postgis_cursor_resultset: FETCH result (" << cursorName_ << "): " << rs_->size() << " rows";
+        MAPNIK_LOG_DEBUG(postgis) << "postgis_cursor_resultset: FETCH result (" << cursorName_ << "): " << rs_->size() << " rows";
 #endif
     }
 
diff --git a/plugins/input/postgis/postgis_datasource.cpp b/plugins/input/postgis/postgis_datasource.cpp
index d0d1f0ab6..c4bc87f0b 100644
--- a/plugins/input/postgis/postgis_datasource.cpp
+++ b/plugins/input/postgis/postgis_datasource.cpp
@@ -82,8 +82,6 @@ postgis_datasource::postgis_datasource(parameters const& params, bool bind)
       intersect_min_scale_(*params_.get<int>("intersect_min_scale", 0)),
       intersect_max_scale_(*params_.get<int>("intersect_max_scale", 0))
 {
-    log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
-
     if (table_.empty())
     {
         throw mapnik::datasource_exception("Postgis Plugin: missing <table> parameter");
@@ -267,12 +265,9 @@ void postgis_datasource::bind() const
                             if (key_field_string)
                             {
                                 key_field_ = std::string(key_field_string);
-#ifdef MAPNIK_DEBUG
-                                if (log_enabled_)
-                                {
-                                    mapnik::log() << "postgis_datasource: auto-detected key field of '"
-                                                  << key_field_ << "' on table '" << geometry_table_ << "'";
-                                }
+#ifdef MAPNIK_LOG
+                                MAPNIK_LOG_DEBUG(postgis) << "postgis_datasource: auto-detected key field of '"
+                                                          << key_field_ << "' on table '" << geometry_table_ << "'";
 #endif
                             }
                         }
@@ -314,18 +309,15 @@ void postgis_datasource::bind() const
                 srid_ = -1;
 
 #ifdef MAPNIK_LOG
-                if (log_enabled_) mapnik::log() << "postgis_datasource: Table " << table_ << " is using SRID=-1";
+                MAPNIK_LOG_DEBUG(postgis) << "postgis_datasource: Table " << table_ << " is using SRID=-1";
 #endif
             }
 
             // At this point the geometry_field may still not be known
             // but we'll catch that where more useful...
 #ifdef MAPNIK_LOG
-            if (log_enabled_)
-            {
-                mapnik::log() << "postgis_datasource: Using SRID=" << srid_;
-                mapnik::log() << "postgis_datasource: Using geometry_column=" << geometryColumn_;
-            }
+            MAPNIK_LOG_DEBUG(postgis) << "postgis_datasource: Using SRID=" << srid_;
+            MAPNIK_LOG_DEBUG(postgis) << "postgis_datasource: Using geometry_column=" << geometryColumn_;
 #endif
 
             // collect attribute desc
@@ -402,23 +394,20 @@ void postgis_datasource::bind() const
                         break;
                     default: // should not get here
 #ifdef MAPNIK_LOG
-                        if (log_enabled_)
-                        {
-                            s.str("");
-                            s << "SELECT oid, typname FROM pg_type WHERE oid = " << type_oid;
+                        s.str("");
+                        s << "SELECT oid, typname FROM pg_type WHERE oid = " << type_oid;
 
-                            shared_ptr<ResultSet> rs_oid = conn->executeQuery(s.str());
-                            if (rs_oid->next())
-                            {
-                                mapnik::log() << "postgis_datasource: Unknown type=" << rs_oid->getValue("typname")
-                                              << " (oid:" << rs_oid->getValue("oid") << ")";
-                            }
-                            else
-                            {
-                                mapnik::log() << "postgis_datasource: Unknown type_oid=" << type_oid;
-                            }
-                            rs_oid->close();
+                        shared_ptr<ResultSet> rs_oid = conn->executeQuery(s.str());
+                        if (rs_oid->next())
+                        {
+                            MAPNIK_LOG_WARN(postgis) << "postgis_datasource: Unknown type=" << rs_oid->getValue("typname")
+                                                     << " (oid:" << rs_oid->getValue("oid") << ")";
                         }
+                        else
+                        {
+                            MAPNIK_LOG_WARN(postgis) << "postgis_datasource: Unknown type_oid=" << type_oid;
+                        }
+                        rs_oid->close();
 #endif
                         break;
                     }
@@ -573,7 +562,6 @@ boost::shared_ptr<IResultSet> postgis_datasource::get_resultset(boost::shared_pt
     else
     {
         // no cursor
-
         return conn->executeQuery(sql, 1);
     }
 }
@@ -859,7 +847,7 @@ box2d<double> postgis_datasource::envelope() const
                 else
                 {
 #ifdef MAPNIK_LOG
-                    mapnik::log() << boost::format("Mapnik LOG> postgis_datasource: Could not determine extent from query: %s") % s.str();
+                    MAPNIK_LOG_DEBUG(postgis) << boost::format("postgis_datasource: Could not determine extent from query: %s") % s.str();
 #endif
                 }
             }
diff --git a/plugins/input/postgis/postgis_datasource.hpp b/plugins/input/postgis/postgis_datasource.hpp
index 9333cd2e8..53c618181 100644
--- a/plugins/input/postgis/postgis_datasource.hpp
+++ b/plugins/input/postgis/postgis_datasource.hpp
@@ -94,7 +94,6 @@ private:
     // params below are for testing purposes only (will likely be removed at any time)
     int intersect_min_scale_;
     int intersect_max_scale_;
-    //bool show_queries_;
 };
 
 #endif // POSTGIS_DATASOURCE_HPP
diff --git a/plugins/input/postgis/postgis_featureset.cpp b/plugins/input/postgis/postgis_featureset.cpp
index a1dacda1c..11e63e62a 100644
--- a/plugins/input/postgis/postgis_featureset.cpp
+++ b/plugins/input/postgis/postgis_featureset.cpp
@@ -199,7 +199,7 @@ feature_ptr postgis_featureset::next()
                     default:
                     {
 #ifdef MAPNIK_LOG
-                        mapnik::log() << "postgis_featureset: Uknown type_oid=" << oid;
+                        MAPNIK_LOG_WARN(postgis) << "postgis_featureset: Uknown type_oid=" << oid;
 #endif
                         break;
                     }
diff --git a/plugins/input/raster/raster_datasource.cpp b/plugins/input/raster/raster_datasource.cpp
index 46bd384e6..b72046e47 100644
--- a/plugins/input/raster/raster_datasource.cpp
+++ b/plugins/input/raster/raster_datasource.cpp
@@ -52,10 +52,8 @@ raster_datasource::raster_datasource(const parameters& params, bool bind)
       desc_(*params.get<std::string>("type"), "utf-8"),
       extent_initialized_(false)
 {
-    log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
-
 #ifdef MAPNIK_LOG
-    if (log_enabled_) mapnik::log() << "raster_datasource: Initializing...";
+    MAPNIK_LOG_DEBUG(raster) << "raster_datasource: Initializing...";
 #endif
 
     boost::optional<std::string> file = params.get<std::string>("file");
@@ -153,7 +151,7 @@ void raster_datasource::bind() const
     }
 
 #ifdef MAPNIK_LOG
-    if (log_enabled_) mapnik::log() << "raster_datasource: Raster size=" << width_ << "," << height_;
+    MAPNIK_LOG_DEBUG(raster) << "raster_datasource: Raster size=" << width_ << "," << height_;
 #endif
 
     is_bound_ = true;
@@ -200,13 +198,13 @@ featureset_ptr raster_datasource::features(query const& q) const
     const int height = int(ext.maxy() + 0.5) - int(ext.miny() + 0.5);
 
 #ifdef MAPNIK_LOG
-    if (log_enabled_) mapnik::log() << "raster_datasource: Box size=" << width << "," << height;
+    MAPNIK_LOG_DEBUG(raster) << "raster_datasource: Box size=" << width << "," << height;
 #endif
 
     if (multi_tiles_)
     {
 #ifdef MAPNIK_LOG
-        if (log_enabled_) mapnik::log() << "raster_datasource: Multi-Tiled policy";
+        MAPNIK_LOG_DEBUG(raster) << "raster_datasource: Multi-Tiled policy";
 #endif
 
         tiled_multi_file_policy policy(filename_, format_, tile_size_, extent_, q.get_bbox(), width_, height_, tile_stride_);
@@ -216,7 +214,7 @@ featureset_ptr raster_datasource::features(query const& q) const
     else if (width * height > 512*512)
     {
 #ifdef MAPNIK_LOG
-        if (log_enabled_) mapnik::log() << "raster_datasource: Tiled policy";
+        MAPNIK_LOG_DEBUG(raster) << "raster_datasource: Tiled policy";
 #endif
 
         tiled_file_policy policy(filename_, format_, 256, extent_, q.get_bbox(), width_, height_);
@@ -226,7 +224,7 @@ featureset_ptr raster_datasource::features(query const& q) const
     else
     {
 #ifdef MAPNIK_LOG
-        if (log_enabled_) mapnik::log() << "raster_datasource: Single file";
+        MAPNIK_LOG_DEBUG(raster) << "raster_datasource: Single file";
 #endif
 
         raster_info info(filename_, format_, extent_, width_, height_);
@@ -239,7 +237,7 @@ featureset_ptr raster_datasource::features(query const& q) const
 featureset_ptr raster_datasource::features_at_point(coord2d const&) const
 {
 #ifdef MAPNIK_LOG
-    if (log_enabled_) mapnik::log() << "raster_datasource: feature_at_point not supported";
+    MAPNIK_LOG_WARN(raster) << "raster_datasource: feature_at_point not supported";
 #endif
 
     return featureset_ptr();
diff --git a/plugins/input/raster/raster_featureset.cpp b/plugins/input/raster/raster_featureset.cpp
index 6c59759d5..4df7e70a6 100644
--- a/plugins/input/raster/raster_featureset.cpp
+++ b/plugins/input/raster/raster_featureset.cpp
@@ -71,8 +71,8 @@ feature_ptr raster_featureset<LookupPolicy>::next()
             std::auto_ptr<image_reader> reader(mapnik::get_image_reader(curIter_->file(),curIter_->format()));
 
 #ifdef MAPNIK_LOG
-            mapnik::log() << "raster_featureset: Reader=" << curIter_->format() << "," << curIter_->file()
-                          << ",size(" << curIter_->width() << "," << curIter_->height() << ")";
+            MAPNIK_LOG_DEBUG(raster) << "raster_featureset: Reader=" << curIter_->format() << "," << curIter_->file()
+                                     << ",size(" << curIter_->width() << "," << curIter_->height() << ")";
 #endif
 
             if (reader.get())
@@ -122,15 +122,15 @@ feature_ptr raster_featureset<LookupPolicy>::next()
         }
         catch (mapnik::image_reader_exception const& ex)
         {
-            std::cerr << "Raster Plugin: image reader exception caught: " << ex.what() << std::endl;
+            MAPNIK_LOG_ERROR(raster) << "Raster Plugin: image reader exception caught: " << ex.what();
         }
         catch (std::exception const& ex)
         {
-            std::cerr << "Raster Plugin: " << ex.what() << std::endl;
+            MAPNIK_LOG_ERROR(raster) << "Raster Plugin: " << ex.what();
         }
         catch (...)
         {
-            std::cerr << "Raster Plugin: exception caught" << std::endl;
+            MAPNIK_LOG_ERROR(raster) << "Raster Plugin: exception caught";
         }
 
         ++curIter_;
diff --git a/plugins/input/raster/raster_featureset.hpp b/plugins/input/raster/raster_featureset.hpp
index f99b0ff9c..d87b0f8dc 100644
--- a/plugins/input/raster/raster_featureset.hpp
+++ b/plugins/input/raster/raster_featureset.hpp
@@ -141,7 +141,7 @@ public:
         double pixel_y = extent.height() / double(height);
 
 #ifdef MAPNIK_LOG
-        mapnik::log() << "tiled_file_policy: Raster Plugin PIXEL SIZE("<< pixel_x << "," << pixel_y << ")";
+        MAPNIK_LOG_DEBUG(raster) << "tiled_file_policy: Raster Plugin PIXEL SIZE("<< pixel_x << "," << pixel_y << ")";
 #endif
 
         box2d<double> e = bbox.intersect(extent);
@@ -165,7 +165,7 @@ public:
         }
 
 #ifdef MAPNIK_LOG
-        mapnik::log() << "tiled_file_policy: Raster Plugin INFO SIZE=" << infos_.size() << " " << file;
+        MAPNIK_LOG_DEBUG(raster) << "tiled_file_policy: Raster Plugin INFO SIZE=" << infos_.size() << " " << file;
 #endif
     }
 
@@ -228,7 +228,7 @@ public:
         double pixel_y = extent.height() / double(height);
 
 #ifdef MAPNIK_LOG
-        mapnik::log() << "tiled_multi_file_policy: Raster Plugin PIXEL SIZE(" << pixel_x << "," << pixel_y << ")";
+        MAPNIK_LOG_DEBUG(raster) << "tiled_multi_file_policy: Raster Plugin PIXEL SIZE(" << pixel_x << "," << pixel_y << ")";
 #endif
 
         // intersection of query with extent => new query
@@ -262,7 +262,7 @@ public:
         }
 
 #ifdef MAPNIK_LOG
-        mapnik::log() << "tiled_multi_file_policy: Raster Plugin INFO SIZE=" << infos_.size() << " " << file_pattern;
+        MAPNIK_LOG_DEBUG(raster) << "tiled_multi_file_policy: Raster Plugin INFO SIZE=" << infos_.size() << " " << file_pattern;
 #endif
     }
 
@@ -313,6 +313,15 @@ template <typename LookupPolicy>
 class raster_featureset : public mapnik::Featureset
 {
     typedef typename LookupPolicy::const_iterator iterator_type;
+
+public:
+    raster_featureset(LookupPolicy const& policy,
+                      box2d<double> const& exttent,
+                      mapnik::query const& q);
+    virtual ~raster_featureset();
+    mapnik::feature_ptr next();
+
+private:
     LookupPolicy policy_;
     int feature_id_;
     mapnik::context_ptr ctx_;
@@ -320,10 +329,6 @@ class raster_featureset : public mapnik::Featureset
     mapnik::box2d<double> bbox_;
     iterator_type curIter_;
     iterator_type endIter_;
-public:
-    raster_featureset(LookupPolicy const& policy,box2d<double> const& exttent, mapnik::query const& q);
-    virtual ~raster_featureset();
-    mapnik::feature_ptr next();
 };
 
 #endif // RASTER_FEATURESET_HPP
diff --git a/plugins/input/rasterlite/rasterlite_datasource.cpp b/plugins/input/rasterlite/rasterlite_datasource.cpp
index 7bb457459..6b2d22c63 100644
--- a/plugins/input/rasterlite/rasterlite_datasource.cpp
+++ b/plugins/input/rasterlite/rasterlite_datasource.cpp
@@ -49,11 +49,14 @@ using mapnik::datasource_exception;
  * Opens a GDALDataset and returns a pointer to it.
  * Caller is responsible for calling GDALClose on it
  */
-inline void *rasterlite_datasource::open_dataset() const
+inline void* rasterlite_datasource::open_dataset() const
 {
-    void *dataset = rasterliteOpen (dataset_name_.c_str(), table_name_.c_str());
+    void* dataset = rasterliteOpen (dataset_name_.c_str(), table_name_.c_str());
 
-    if (! dataset) throw datasource_exception("Rasterlite Plugin: Error opening dataset");
+    if (! dataset)
+    {
+        throw datasource_exception("Rasterlite Plugin: Error opening dataset");
+    }
 
     if (rasterliteIsError (dataset))
     {
@@ -68,15 +71,12 @@ inline void *rasterlite_datasource::open_dataset() const
 }
 
 
-
 rasterlite_datasource::rasterlite_datasource(parameters const& params, bool bind)
     : datasource(params),
       desc_(*params.get<std::string>("type"),"utf-8")
 {
-    log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
-
 #ifdef MAPNIK_LOG
-    if (log_enabled_) mapnik::log() << "rasterlite_datasource: Initializing...";
+    MAPNIK_LOG_DEBUG(rasterlite) << "rasterlite_datasource: Initializing...";
 #endif
 
     boost::optional<std::string> file = params.get<std::string>("file");
@@ -120,42 +120,41 @@ void rasterlite_datasource::bind() const
     extent_.init(x0,y0,x1,y1);
 
 #ifdef MAPNIK_LOG
-    if (log_enabled_)
+    int srid, auth_srid;
+    const char *auth_name;
+    const char *ref_sys_name;
+    const char *proj4text;
+
+    int tile_count;
+    double pixel_x_size, pixel_y_size;
+    int levels = rasterliteGetLevels (dataset);
+
+    if (rasterliteGetSrid(dataset, &srid, &auth_name, &auth_srid, &ref_sys_name, &proj4text) != RASTERLITE_OK)
     {
-        int srid, auth_srid;
-        const char *auth_name;
-        const char *ref_sys_name;
-        const char *proj4text;
+        std::string error (rasterliteGetLastError(dataset));
 
-        int tile_count;
-        double pixel_x_size, pixel_y_size;
-        int levels = rasterliteGetLevels (dataset);
+        rasterliteClose (dataset);
 
-        if (rasterliteGetSrid(dataset, &srid, &auth_name, &auth_srid, &ref_sys_name, &proj4text) != RASTERLITE_OK)
+        throw datasource_exception(error);
+    }
+
+    MAPNIK_LOG_DEBUG(rasterlite) << "rasterlite_datasource: Data Source=" << rasterliteGetTablePrefix(dataset);
+    MAPNIK_LOG_DEBUG(rasterlite) << "rasterlite_datasource: SRID=" << srid;
+    MAPNIK_LOG_DEBUG(rasterlite) << "rasterlite_datasource: Authority=" << auth_name;
+    MAPNIK_LOG_DEBUG(rasterlite) << "rasterlite_datasource: AuthSRID=" << auth_srid;
+    MAPNIK_LOG_DEBUG(rasterlite) << "rasterlite_datasource: RefSys Name=" << ref_sys_name;
+    MAPNIK_LOG_DEBUG(rasterlite) << "rasterlite_datasource: Proj4Text=" << proj4text;
+    MAPNIK_LOG_DEBUG(rasterlite) << "rasterlite_datasource: Extent=" << x0 << "," << y0 << " " << x1 << "," << y1 << ")";
+    MAPNIK_LOG_DEBUG(rasterlite) << "rasterlite_datasource: Levels=" << levels;
+
+    for (int i = 0; i < levels; i++)
+    {
+        if (rasterliteGetResolution(dataset, i, &pixel_x_size, &pixel_y_size, &tile_count) == RASTERLITE_OK)
         {
-            std::string error (rasterliteGetLastError(dataset));
-
-            rasterliteClose (dataset);
-
-            throw datasource_exception(error);
-        }
-
-        mapnik::log() << "rasterlite_datasource: Data Source=" << rasterliteGetTablePrefix(dataset);
-        mapnik::log() << "rasterlite_datasource: SRID=" << srid;
-        mapnik::log() << "rasterlite_datasource: Authority=" << auth_name;
-        mapnik::log() << "rasterlite_datasource: AuthSRID=" << auth_srid;
-        mapnik::log() << "rasterlite_datasource: RefSys Name=" << ref_sys_name;
-        mapnik::log() << "rasterlite_datasource: Proj4Text=" << proj4text;
-        mapnik::log() << "rasterlite_datasource: Extent=" << x0 << "," << y0 << " " << x1 << "," << y1 << ")";
-        mapnik::log() << "rasterlite_datasource: Levels=" << levels;
-
-        for (int i = 0; i < levels; i++)
-        {
-            if (rasterliteGetResolution(dataset, i, &pixel_x_size, &pixel_y_size, &tile_count) == RASTERLITE_OK)
-            {
-                mapnik::log() << "rasterlite_datasource: Level=" << i
-                              << " x=" << pixel_x_size << " y=" << pixel_y_size << " tiles=" << tile_count;
-            }
+            MAPNIK_LOG_DEBUG(rasterlite) << "rasterlite_datasource: Level=" << i
+                                         << " x=" << pixel_x_size
+                                         << " y=" << pixel_y_size
+                                         << " tiles=" << tile_count;
         }
     }
 #endif
diff --git a/plugins/input/rasterlite/rasterlite_featureset.cpp b/plugins/input/rasterlite/rasterlite_featureset.cpp
index 00fc4627c..aa289957a 100644
--- a/plugins/input/rasterlite/rasterlite_featureset.cpp
+++ b/plugins/input/rasterlite/rasterlite_featureset.cpp
@@ -42,7 +42,8 @@ using mapnik::query;
 using mapnik::feature_factory;
 
 
-rasterlite_featureset::rasterlite_featureset(void* dataset, rasterlite_query q)
+rasterlite_featureset::rasterlite_featureset(void* dataset,
+                                             rasterlite_query q)
     : dataset_(dataset),
       gquery_(q),
       first_(true),
@@ -55,7 +56,7 @@ rasterlite_featureset::rasterlite_featureset(void* dataset, rasterlite_query q)
 rasterlite_featureset::~rasterlite_featureset()
 {
 #ifdef MAPNIK_LOG
-    mapnik::log() << "rasterlite_featureset: Closing";
+    MAPNIK_LOG_DEBUG(rasterlite) << "rasterlite_featureset: Closing";
 #endif
 
     rasterliteClose(dataset_);
@@ -88,7 +89,7 @@ feature_ptr rasterlite_featureset::next()
 feature_ptr rasterlite_featureset::get_feature(mapnik::query const& q)
 {
 #ifdef MAPNIK_LOG
-    mapnik::log() << "rasterlite_featureset: Running get_feature";
+    MAPNIK_LOG_DEBUG(rasterlite) << "rasterlite_featureset: Running get_feature";
 #endif
 
     feature_ptr feature(feature_factory::create(ctx_,1));
@@ -106,12 +107,12 @@ feature_ptr rasterlite_featureset::get_feature(mapnik::query const& q)
         (intersect.width() / (double) width) : (intersect.height() / (double) height);
 
 #ifdef MAPNIK_LOG
-    mapnik::log() << "rasterlite_featureset: Raster extent=" << raster_extent;
-    mapnik::log() << "rasterlite_featureset: View extent=" << q.get_bbox();
-    mapnik::log() << "rasterlite_featureset: Intersect extent=" << intersect;
-    mapnik::log() << "rasterlite_featureset: Query resolution=" << boost::get<0>(q.resolution())  << "," << boost::get<1>(q.resolution());
-    mapnik::log() << "rasterlite_featureset: Size=" << width << " " << height;
-    mapnik::log() << "rasterlite_featureset: Pixel Size=" << pixel_size;
+    MAPNIK_LOG_DEBUG(rasterlite) << "rasterlite_featureset: Raster extent=" << raster_extent;
+    MAPNIK_LOG_DEBUG(rasterlite) << "rasterlite_featureset: View extent=" << q.get_bbox();
+    MAPNIK_LOG_DEBUG(rasterlite) << "rasterlite_featureset: Intersect extent=" << intersect;
+    MAPNIK_LOG_DEBUG(rasterlite) << "rasterlite_featureset: Query resolution=" << boost::get<0>(q.resolution())  << "," << boost::get<1>(q.resolution());
+    MAPNIK_LOG_DEBUG(rasterlite) << "rasterlite_featureset: Size=" << width << " " << height;
+    MAPNIK_LOG_DEBUG(rasterlite) << "rasterlite_featureset: Pixel Size=" << pixel_size;
 #endif
 
     if (width > 0 && height > 0)
@@ -146,12 +147,12 @@ feature_ptr rasterlite_featureset::get_feature(mapnik::query const& q)
                 free (raster);
 
 #ifdef MAPNIK_LOG
-                mapnik::log() << "rasterlite_featureset: Done";
+                MAPNIK_LOG_DEBUG(rasterlite) << "rasterlite_featureset: Done";
 #endif
             }
             else
             {
-                std::cerr << "Rasterlite Plugin: Error " << rasterliteGetLastError (dataset_) << std::endl;
+                MAPNIK_LOG_ERROR(rasterlite) << "Rasterlite Plugin: Error " << rasterliteGetLastError (dataset_);
             }
         }
 
diff --git a/plugins/input/rasterlite/rasterlite_featureset.hpp b/plugins/input/rasterlite/rasterlite_featureset.hpp
index 4f7572da6..d033e478d 100644
--- a/plugins/input/rasterlite/rasterlite_featureset.hpp
+++ b/plugins/input/rasterlite/rasterlite_featureset.hpp
@@ -36,7 +36,8 @@ typedef boost::variant<mapnik::query,mapnik::coord2d> rasterlite_query;
 class rasterlite_featureset : public mapnik::Featureset
 {
 public:
-    rasterlite_featureset(void* dataset, rasterlite_query q);
+    rasterlite_featureset(void* dataset,
+                          rasterlite_query q);
     virtual ~rasterlite_featureset();
     mapnik::feature_ptr next();
 
diff --git a/plugins/input/shape/shape_datasource.cpp b/plugins/input/shape/shape_datasource.cpp
index 8228a3b5d..26092b11c 100644
--- a/plugins/input/shape/shape_datasource.cpp
+++ b/plugins/input/shape/shape_datasource.cpp
@@ -63,8 +63,6 @@ shape_datasource::shape_datasource(const parameters &params, bool bind)
       row_limit_(*params_.get<int>("row_limit",0)),
       desc_(*params.get<std::string>("type"), *params.get<std::string>("encoding","utf-8"))
 {
-    log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
-
     boost::optional<std::string> file = params.get<std::string>("file");
     if (!file) throw datasource_exception("Shape Plugin: missing <file> parameter");
 
@@ -146,7 +144,7 @@ void shape_datasource::bind() const
                 // I - long
                 // G - ole
                 // + - autoincrement
-                if (log_enabled_) mapnik::log() << "shape_datasource: Unknown type=" << fd.type_;
+                MAPNIK_LOG_WARN(shape) << "shape_datasource: Unknown type=" << fd.type_;
 #endif
                 break;
             }
@@ -159,17 +157,17 @@ void shape_datasource::bind() const
     }
     catch (const datasource_exception& ex)
     {
-        std::cerr << "Shape Plugin: error processing field attributes, " << ex.what() << std::endl;
+        MAPNIK_LOG_ERROR(shape) << "Shape Plugin: error processing field attributes, " << ex.what();
         throw;
     }
     catch (const std::exception& ex)
     {
-        std::cerr << "Shape Plugin: error processing field attributes, " << ex.what() << std::endl;
+        MAPNIK_LOG_ERROR(shape) << "Shape Plugin: error processing field attributes, " << ex.what();
         throw;
     }
     catch (...) // exception: pipe_select_interrupter: Too many open files
     {
-        std::cerr << "Shape Plugin: error processing field attributes" << std::endl;
+        MAPNIK_LOG_ERROR(shape) << "Shape Plugin: error processing field attributes";
         throw;
     }
 
@@ -209,16 +207,13 @@ void shape_datasource::init(shape_io& shape) const
     shape.shp().read_envelope(extent_);
 
 #ifdef MAPNIK_LOG
-    if (log_enabled_)
-    {
-        double zmin = shape.shp().read_double();
-        double zmax = shape.shp().read_double();
-        double mmin = shape.shp().read_double();
-        double mmax = shape.shp().read_double();
+    const double zmin = shape.shp().read_double();
+    const double zmax = shape.shp().read_double();
+    const double mmin = shape.shp().read_double();
+    const double mmax = shape.shp().read_double();
 
-        mapnik::log() << "shape_datasource: Z min/max=" << zmin << "," << zmax;
-        mapnik::log() << "shape_datasource: M min/max=" << mmin << "," << mmax;
-    }
+    MAPNIK_LOG_DEBUG(shape) << "shape_datasource: Z min/max=" << zmin << "," << zmax;
+    MAPNIK_LOG_DEBUG(shape) << "shape_datasource: M min/max=" << mmin << "," << mmax;
 #else
     shape.shp().skip(4*8);
 #endif
@@ -237,18 +232,15 @@ void shape_datasource::init(shape_io& shape) const
     //else
     //{
     // #ifdef MAPNIK_LOG
-    //    mapnik::log() << "shape_datasource: No .index file found for "
-    //                  << shape_name_ << ".shp, use the 'shapeindex' program to build an index for faster rendering";
+    //    MAPNIK_LOG_DEBUG(shape) << "shape_datasource: No .index file found for "
+    //                            << shape_name_ << ".shp, use the 'shapeindex' program to build an index for faster rendering";
     // #endif
     //}
 
 #ifdef MAPNIK_LOG
-    if (log_enabled_)
-    {
-        mapnik::log() << "shape_datasource: Extent=" << extent_;
-        mapnik::log() << "shape_datasource: File length=" << file_length_;
-        mapnik::log() << "shape_datasource: Shape type=" << shape_type_;
-    }
+    MAPNIK_LOG_DEBUG(shape) << "shape_datasource: Extent=" << extent_;
+    MAPNIK_LOG_DEBUG(shape) << "shape_datasource: File length=" << file_length_;
+    MAPNIK_LOG_DEBUG(shape) << "shape_datasource: Shape type=" << shape_type_;
 #endif
 
 }
@@ -390,4 +382,3 @@ boost::optional<mapnik::datasource::geometry_t> shape_datasource::get_geometry_t
     }
     return result;
 }
-
diff --git a/plugins/input/shape/shape_featureset.cpp b/plugins/input/shape/shape_featureset.cpp
index 70c017914..01259e33d 100644
--- a/plugins/input/shape/shape_featureset.cpp
+++ b/plugins/input/shape/shape_featureset.cpp
@@ -128,8 +128,9 @@ feature_ptr shape_featureset<filterT>::next()
                 if (shape_.type() == shape_io::shape_null)
                 {
                     pos += std::streampos(12);
+
                     // TODO handle the shapes
-                    std::cerr << "NULL SHAPE len=" << shape_.reclength_ << std::endl;
+                    MAPNIK_LOG_WARN(shape) << "shape_featureset: NULL SHAPE len=" << shape_.reclength_;
                 }
                 else if (filter_.pass(shape_.current_extent()))
                 {
@@ -147,7 +148,7 @@ feature_ptr shape_featureset<filterT>::next()
                 else
                 {
 #ifdef MAPNIK_LOG
-                    mapnik::log() << "shape_featureset: Total shapes read=" << count_;
+                    MAPNIK_LOG_DEBUG(shape) << "shape_featureset: Total shapes read=" << count_;
 #endif
                     return feature_ptr();
                 }
@@ -248,7 +249,7 @@ feature_ptr shape_featureset<filterT>::next()
             }
             catch (...)
             {
-                std::cerr << "Shape Plugin: error processing attributes " << std::endl;
+                MAPNIK_LOG_ERROR(shape) << "Shape Plugin: error processing attributes";
             }
         }
 
@@ -257,7 +258,7 @@ feature_ptr shape_featureset<filterT>::next()
     else
     {
 #ifdef MAPNIK_LOG
-        mapnik::log() << "shape_featureset: Total shapes read=" << count_;
+        MAPNIK_LOG_DEBUG(shape) << "shape_featureset: Total shapes read=" << count_;
 #endif
         return feature_ptr();
     }
diff --git a/plugins/input/shape/shape_featureset.hpp b/plugins/input/shape/shape_featureset.hpp
index 94cea12ef..3b77bbbdc 100644
--- a/plugins/input/shape/shape_featureset.hpp
+++ b/plugins/input/shape/shape_featureset.hpp
@@ -42,16 +42,6 @@ using mapnik::context_ptr;
 template <typename filterT>
 class shape_featureset : public Featureset
 {
-    filterT filter_;
-    shape_io shape_;
-    box2d<double> query_ext_;
-    boost::scoped_ptr<transcoder> tr_;
-    long file_length_;
-    std::vector<int> attr_ids_;
-    const int row_limit_;
-    mutable int count_;
-    context_ptr ctx_;
-
 public:
     shape_featureset(filterT const& filter,
                      std::string const& shape_file,
@@ -61,6 +51,17 @@ public:
                      int row_limit);
     virtual ~shape_featureset();
     feature_ptr next();
+
+private:
+    filterT filter_;
+    shape_io shape_;
+    box2d<double> query_ext_;
+    boost::scoped_ptr<transcoder> tr_;
+    long file_length_;
+    std::vector<int> attr_ids_;
+    const int row_limit_;
+    mutable int count_;
+    context_ptr ctx_;
 };
 
 #endif //SHAPE_FEATURESET_HPP
diff --git a/plugins/input/shape/shape_index_featureset.cpp b/plugins/input/shape/shape_index_featureset.cpp
index 90cf6942f..d37b42d4d 100644
--- a/plugins/input/shape/shape_index_featureset.cpp
+++ b/plugins/input/shape/shape_index_featureset.cpp
@@ -68,7 +68,7 @@ shape_index_featureset<filterT>::shape_index_featureset(filterT const& filter,
     std::sort(ids_.begin(), ids_.end());
 
 #ifdef MAPNIK_LOG
-    mapnik::log() << "shape_index_featureset: Query size=" << ids_.size();
+    MAPNIK_LOG_DEBUG(shape) << "shape_index_featureset: Query size=" << ids_.size();
 #endif
 
     itr_ = ids_.begin();
@@ -195,7 +195,7 @@ feature_ptr shape_index_featureset<filterT>::next()
             }
             catch (...)
             {
-                std::cerr << "Shape Plugin: error processing attributes" << std::endl;
+                MAPNIK_LOG_ERROR(shape) << "Shape Plugin: error processing attributes";
             }
         }
         return feature;
@@ -204,7 +204,7 @@ feature_ptr shape_index_featureset<filterT>::next()
     {
 
 #ifdef MAPNIK_LOG
-        mapnik::log() << "shape_index_featureset: " << count_ << " features";
+        MAPNIK_LOG_DEBUG(shape) << "shape_index_featureset: " << count_ << " features";
 #endif
         return feature_ptr();
     }
diff --git a/plugins/input/shape/shape_index_featureset.hpp b/plugins/input/shape/shape_index_featureset.hpp
index 7867c23e0..410a10358 100644
--- a/plugins/input/shape/shape_index_featureset.hpp
+++ b/plugins/input/shape/shape_index_featureset.hpp
@@ -52,9 +52,7 @@ public:
                            std::string const& encoding,
                            std::string const& shape_name,
                            int row_limit);
-
     virtual ~shape_index_featureset();
-
     feature_ptr next();
 
 private:
diff --git a/plugins/input/shape/shape_io.cpp b/plugins/input/shape/shape_io.cpp
index 6ce89fbf0..ddc196c10 100644
--- a/plugins/input/shape/shape_io.cpp
+++ b/plugins/input/shape/shape_io.cpp
@@ -59,7 +59,7 @@ shape_io::shape_io(const std::string& shape_name, bool open_index)
         catch (...)
         {
 #ifdef MAPNIK_LOG
-            mapnik::log() << "shape_io: Could not open index=" << shape_name << INDEX;
+            MAPNIK_LOG_WARN(shape) << "shape_io: Could not open index=" << shape_name << INDEX;
 #endif
         }
     }
@@ -233,5 +233,3 @@ void shape_io::read_polygon(mapnik::geometry_container & geom)
     //   double m=record.read_double();
     //}
 }
-
-
diff --git a/plugins/input/sqlite/sqlite_datasource.cpp b/plugins/input/sqlite/sqlite_datasource.cpp
index 652178321..b3000c778 100644
--- a/plugins/input/sqlite/sqlite_datasource.cpp
+++ b/plugins/input/sqlite/sqlite_datasource.cpp
@@ -70,8 +70,6 @@ sqlite_datasource::sqlite_datasource(parameters const& params, bool bind)
       desc_(*params_.get<std::string>("type"), *params_.get<std::string>("encoding", "utf-8")),
       format_(mapnik::wkbAuto)
 {
-    log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
-
     /* TODO
        - throw if no primary key but spatial index is present?
        - remove auto-indexing
@@ -218,7 +216,7 @@ void sqlite_datasource::bind() const
          iter != init_statements_.end(); ++iter)
     {
 #ifdef MAPNIK_LOG
-        if (log_enabled_) mapnik::log() << "sqlite_datasource: Execute init sql=" << *iter;
+        MAPNIK_LOG_DEBUG(sqlite) << "sqlite_datasource: Execute init sql=" << *iter;
 #endif
         dataset_->execute(*iter);
     }
@@ -616,11 +614,7 @@ featureset_ptr sqlite_datasource::features(query const& q) const
         }
 
 #ifdef MAPNIK_LOG
-        if (log_enabled_)
-        {
-            mapnik::log() << "sqlite_datasource: Table=" << table_;
-            mapnik::log() << "sqlite_datasource: Query=" << s.str();
-        }
+        MAPNIK_LOG_DEBUG(sqlite) << "sqlite_datasource: " << s.str();
 #endif
 
         boost::shared_ptr<sqlite_resultset> rs(dataset_->execute_query(s.str()));
@@ -704,7 +698,7 @@ featureset_ptr sqlite_datasource::features_at_point(coord2d const& pt) const
         }
 
 #ifdef MAPNIK_LOG
-        if (log_enabled_) mapnik::log() << "sqlite_datasource: " << s.str();
+        MAPNIK_LOG_DEBUG(sqlite) << "sqlite_datasource: " << s.str();
 #endif
 
         boost::shared_ptr<sqlite_resultset> rs(dataset_->execute_query(s.str()));
diff --git a/plugins/input/sqlite/sqlite_featureset.cpp b/plugins/input/sqlite/sqlite_featureset.cpp
index f373641a4..ccc48105c 100644
--- a/plugins/input/sqlite/sqlite_featureset.cpp
+++ b/plugins/input/sqlite/sqlite_featureset.cpp
@@ -126,7 +126,7 @@ feature_ptr sqlite_featureset::next()
 
             default:
 #ifdef MAPNIK_LOG
-                mapnik::log() << "sqlite_featureset: Field=" << fld_name_str << " unhandled type_oid=" << type_oid;
+                MAPNIK_LOG_WARN(sqlite) << "sqlite_featureset: Field=" << fld_name_str << " unhandled type_oid=" << type_oid;
 #endif
                 break;
             }
diff --git a/src/debug.cpp b/src/debug.cpp
index 5ce8bb213..684c7e151 100644
--- a/src/debug.cpp
+++ b/src/debug.cpp
@@ -20,13 +20,17 @@
  *
  *****************************************************************************/
 
+// mapnik
 #include <mapnik/debug.hpp>
 
-#ifdef MAPNIK_LOG
-namespace mapnik {
-    namespace logger {
-        severity::type severity::severity_level_ =
-            MAPNIK_DEBUG_AS_BOOL ? severity::debug : severity::error;
-    }
+namespace mapnik { namespace logger {
+
+
+severity::type severity::severity_level_ =
+    MAPNIK_DEBUG_AS_BOOL ? severity::debug : severity::error;
+
+severity::severity_map severity::object_severity_level_ = severity::severity_map();
+
+
+}
 }
-#endif
diff --git a/workspace/bindings.pri b/workspace/bindings.pri
index 2798142e7..397285efd 100644
--- a/workspace/bindings.pri
+++ b/workspace/bindings.pri
@@ -23,6 +23,7 @@ SOURCES += \
 	$$PWD/../bindings/python/mapnik_image_view.cpp \
 	$$PWD/../bindings/python/mapnik_inmem_metawriter.cpp \
 	$$PWD/../bindings/python/mapnik_layer.cpp \
+	$$PWD/../bindings/python/mapnik_logger.cpp \
 	$$PWD/../bindings/python/mapnik_line_pattern_symbolizer.cpp \
 	$$PWD/../bindings/python/mapnik_line_symbolizer.cpp \
 	$$PWD/../bindings/python/mapnik_map.cpp \
diff --git a/workspace/mapnik.pro b/workspace/mapnik.pro
index 3f29a2e07..f74500532 100644
--- a/workspace/mapnik.pro
+++ b/workspace/mapnik.pro
@@ -323,5 +323,5 @@ include(plugins.pri)
 include(bindings.pri)
 
 unix {
-    DEFINES += LINUX=1
+    DEFINES += LINUX=1 MAPNIK_LOG=1
 }