diff --git a/SConstruct b/SConstruct
index 569ff4b09..419bc56d5 100644
--- a/SConstruct
+++ b/SConstruct
@@ -325,7 +325,7 @@ opts.AddVariables(
     # Variables affecting rendering back-ends
     
     BoolVariable('RENDERING_STATS', 'Output rendering statistics during style processing', 'False'),
-    
+
     BoolVariable('INTERNAL_LIBAGG', 'Use provided libagg', 'True'),
 
     BoolVariable('SVG_RENDERER', 'build support for native svg renderer', 'False'),
@@ -345,7 +345,12 @@ opts.AddVariables(
     PathVariable('SQLITE_LIBS', 'Search path for SQLITE library files', '/usr/' + LIBDIR_SCHEMA, PathVariable.PathAccept),
     PathVariable('RASTERLITE_INCLUDES', 'Search path for RASTERLITE include files', '/usr/include/', PathVariable.PathAccept),
     PathVariable('RASTERLITE_LIBS', 'Search path for RASTERLITE library files', '/usr/' + LIBDIR_SCHEMA, PathVariable.PathAccept),
-    
+
+    # Variables for logging and statistics
+    BoolVariable('ENABLE_LOG', 'Enable logging, which is enabled by default when building in *debug*', 'False'),
+    BoolVariable('ENABLE_STATS', 'Enable global statistics during map processing', 'False'),
+    ('LOG_FORMAT_STRING', 'The format string used before log output string, piped through strftime (max length of 255 characters)', 'Mapnik LOG> %Y-%m-%d %H:%M:%S:'),
+
     # Other variables
     BoolVariable('SHAPE_MEMORY_MAPPED_FILE', 'Utilize memory-mapped files in Shapefile Plugin (higher memory usage, better performance)', 'True'),
     ('SYSTEM_FONTS','Provide location for python bindings to register fonts (if given aborts installation of bundled DejaVu fonts)',''),
@@ -1163,7 +1168,7 @@ if not preconfigured:
             env.Append(CXXFLAGS = '-DBOOST_REGEX_HAS_ICU')
         else:
             env['SKIPPED_DEPS'].append('boost_regex_icu')
-    
+
     env['REQUESTED_PLUGINS'] = [ driver.strip() for driver in Split(env['INPUT_PLUGINS'])]
     
     if len(env['REQUESTED_PLUGINS']):
@@ -1411,10 +1416,26 @@ if not preconfigured:
         # Common debugging flags.
         # http://lists.fedoraproject.org/pipermail/devel/2010-November/144952.html
         debug_flags  = '-g -fno-omit-frame-pointer -DDEBUG -DMAPNIK_DEBUG'
-        
         ndebug_flags = '-DNDEBUG'
-       
-        
+
+        # Enable logging in debug mode (always) and release mode (when specified)
+        log_enabled = ' -DMAPNIK_LOG -DMAPNIK_LOG_FORMAT="%s"' % env['LOG_FORMAT_STRING']
+
+        if env['DEBUG']:
+            debug_flags += log_enabled
+        else:
+            if env['ENABLE_LOG']:
+                ndebug_flags += log_enabled
+
+        # Enable statistics reporting
+        if env['ENABLE_STATS']:
+            debug_flags += ' -DMAPNIK_STATS'
+            ndebug_flags += ' -DMAPNIK_STATS'
+
+        # Add rdynamic to allow using statics between application and plugins
+        # http://stackoverflow.com/questions/8623657/multiple-instances-of-singleton-across-shared-libraries-on-linux
+        env.MergeFlags('-rdynamic')
+
         # Customizing the C++ compiler flags depending on: 
         #  (1) the C++ compiler used; and
         #  (2) whether debug binaries are requested.
diff --git a/bindings/python/mapnik_color.cpp b/bindings/python/mapnik_color.cpp
index 1b6e34fb2..82611ff48 100644
--- a/bindings/python/mapnik_color.cpp
+++ b/bindings/python/mapnik_color.cpp
@@ -19,7 +19,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 // boost
 #include <boost/python.hpp>
diff --git a/bindings/python/mapnik_coord.cpp b/bindings/python/mapnik_coord.cpp
index 103dad3f8..b9b4e6277 100644
--- a/bindings/python/mapnik_coord.cpp
+++ b/bindings/python/mapnik_coord.cpp
@@ -19,7 +19,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 // boost
 #include <boost/python.hpp>
diff --git a/bindings/python/mapnik_datasource.cpp b/bindings/python/mapnik_datasource.cpp
index d7b83040e..7d424431d 100644
--- a/bindings/python/mapnik_datasource.cpp
+++ b/bindings/python/mapnik_datasource.cpp
@@ -19,10 +19,11 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
+
 // boost
 #include <boost/python.hpp>
 #include <boost/python/detail/api_placeholder.hpp>
+
 // stl
 #include <sstream>
 #include <vector>
@@ -89,6 +90,7 @@ 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_datasource_cache.cpp b/bindings/python/mapnik_datasource_cache.cpp
index 6b62b7129..c4381837b 100644
--- a/bindings/python/mapnik_datasource_cache.cpp
+++ b/bindings/python/mapnik_datasource_cache.cpp
@@ -20,8 +20,6 @@
  *
  *****************************************************************************/
 
-//$Id$
-
 #include <boost/python.hpp>
 #include <mapnik/datasource_cache.hpp>
 
diff --git a/bindings/python/mapnik_envelope.cpp b/bindings/python/mapnik_envelope.cpp
index 5aa35a0bf..099f319cc 100644
--- a/bindings/python/mapnik_envelope.cpp
+++ b/bindings/python/mapnik_envelope.cpp
@@ -19,7 +19,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id: mapnik_envelope.cc 27 2005-03-30 21:45:40Z pavlenko $
 
 // boost
 #include <boost/python.hpp>
diff --git a/bindings/python/mapnik_expression.cpp b/bindings/python/mapnik_expression.cpp
index d95d5879b..b75281394 100644
--- a/bindings/python/mapnik_expression.cpp
+++ b/bindings/python/mapnik_expression.cpp
@@ -19,9 +19,11 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
+// boost
 #include <boost/python.hpp>
+#include <boost/variant.hpp>
+
 // mapnik
 #include <mapnik/feature.hpp>
 #include <mapnik/expression.hpp>
@@ -30,7 +32,6 @@
 #include <mapnik/parse_path.hpp>
 #include <mapnik/value.hpp>
 
-#include <boost/variant.hpp>
 
 using mapnik::Feature;
 using mapnik::expression_ptr;
diff --git a/bindings/python/mapnik_feature.cpp b/bindings/python/mapnik_feature.cpp
index e55842e26..c4d7f75b6 100644
--- a/bindings/python/mapnik_feature.cpp
+++ b/bindings/python/mapnik_feature.cpp
@@ -19,13 +19,10 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 // boost
-
 #include <boost/python/suite/indexing/indexing_suite.hpp>
 //#include <boost/python/suite/indexing/map_indexing_suite.hpp>
-
 #include <boost/python/iterator.hpp>
 #include <boost/python/call_method.hpp>
 #include <boost/python/tuple.hpp>
diff --git a/bindings/python/mapnik_featureset.cpp b/bindings/python/mapnik_featureset.cpp
index c7f4722d3..21eb7b796 100644
--- a/bindings/python/mapnik_featureset.cpp
+++ b/bindings/python/mapnik_featureset.cpp
@@ -19,10 +19,10 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 // boost
 #include <boost/python.hpp>
+
 // mapnik
 #include <mapnik/feature.hpp>
 #include <mapnik/datasource.hpp>
diff --git a/bindings/python/mapnik_font_engine.cpp b/bindings/python/mapnik_font_engine.cpp
index 1b2596e3c..5f4160756 100644
--- a/bindings/python/mapnik_font_engine.cpp
+++ b/bindings/python/mapnik_font_engine.cpp
@@ -19,7 +19,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 #include <boost/python.hpp>
 #include <mapnik/font_engine_freetype.hpp>
diff --git a/bindings/python/mapnik_geometry.cpp b/bindings/python/mapnik_geometry.cpp
index 06aa96207..cd2506628 100644
--- a/bindings/python/mapnik_geometry.cpp
+++ b/bindings/python/mapnik_geometry.cpp
@@ -17,7 +17,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 // boost
 #include <boost/python.hpp>
diff --git a/bindings/python/mapnik_grid.cpp b/bindings/python/mapnik_grid.cpp
index 2cfce2b7b..95a20efaf 100644
--- a/bindings/python/mapnik_grid.cpp
+++ b/bindings/python/mapnik_grid.cpp
@@ -19,7 +19,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 // boost
 #include <boost/python.hpp>
diff --git a/bindings/python/mapnik_grid_view.cpp b/bindings/python/mapnik_grid_view.cpp
index bb39a5b88..926ee18f6 100644
--- a/bindings/python/mapnik_grid_view.cpp
+++ b/bindings/python/mapnik_grid_view.cpp
@@ -19,7 +19,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 // boost
 #include <boost/python.hpp>
diff --git a/bindings/python/mapnik_image.cpp b/bindings/python/mapnik_image.cpp
index 5ade76573..ff4d17c0b 100644
--- a/bindings/python/mapnik_image.cpp
+++ b/bindings/python/mapnik_image.cpp
@@ -19,7 +19,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 extern "C"
 {
diff --git a/bindings/python/mapnik_image_view.cpp b/bindings/python/mapnik_image_view.cpp
index 9e07a29e6..f3cf2e44f 100644
--- a/bindings/python/mapnik_image_view.cpp
+++ b/bindings/python/mapnik_image_view.cpp
@@ -19,7 +19,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 extern "C"
 {
diff --git a/bindings/python/mapnik_inmem_metawriter.cpp b/bindings/python/mapnik_inmem_metawriter.cpp
index 44ebbdd08..34760f45b 100644
--- a/bindings/python/mapnik_inmem_metawriter.cpp
+++ b/bindings/python/mapnik_inmem_metawriter.cpp
@@ -19,7 +19,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 // boost
 #include <boost/python.hpp>
diff --git a/bindings/python/mapnik_layer.cpp b/bindings/python/mapnik_layer.cpp
index 512d895b4..0b2e8d63b 100644
--- a/bindings/python/mapnik_layer.cpp
+++ b/bindings/python/mapnik_layer.cpp
@@ -19,8 +19,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id: mapnik_layer.cc 17 2005-03-08 23:58:43Z pavlenko $
-
 
 // boost
 #include <boost/python.hpp>
diff --git a/bindings/python/mapnik_line_pattern_symbolizer.cpp b/bindings/python/mapnik_line_pattern_symbolizer.cpp
index aae24bac0..e982edf05 100644
--- a/bindings/python/mapnik_line_pattern_symbolizer.cpp
+++ b/bindings/python/mapnik_line_pattern_symbolizer.cpp
@@ -19,7 +19,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 #include <boost/python.hpp>
 
diff --git a/bindings/python/mapnik_line_symbolizer.cpp b/bindings/python/mapnik_line_symbolizer.cpp
index 9c7053b90..93f96e693 100644
--- a/bindings/python/mapnik_line_symbolizer.cpp
+++ b/bindings/python/mapnik_line_symbolizer.cpp
@@ -19,7 +19,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 #include <boost/python.hpp>
 #include "mapnik_enumeration.hpp"
diff --git a/bindings/python/mapnik_map.cpp b/bindings/python/mapnik_map.cpp
index c6e2467cd..3bc1ca983 100644
--- a/bindings/python/mapnik_map.cpp
+++ b/bindings/python/mapnik_map.cpp
@@ -19,7 +19,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id: mapnik_map.cc 17 2005-03-08 23:58:43Z pavlenko $
 
 // boost
 #include <boost/python.hpp>
diff --git a/bindings/python/mapnik_markers_symbolizer.cpp b/bindings/python/mapnik_markers_symbolizer.cpp
index 17d860f11..d6388c6f7 100644
--- a/bindings/python/mapnik_markers_symbolizer.cpp
+++ b/bindings/python/mapnik_markers_symbolizer.cpp
@@ -19,9 +19,9 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 #include <boost/python.hpp>
+
 #include <mapnik/graphics.hpp>
 #include <mapnik/image_util.hpp>
 #include <mapnik/markers_symbolizer.hpp>
diff --git a/bindings/python/mapnik_palette.cpp b/bindings/python/mapnik_palette.cpp
index 4e6c39666..54b0b3146 100644
--- a/bindings/python/mapnik_palette.cpp
+++ b/bindings/python/mapnik_palette.cpp
@@ -19,7 +19,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 // boost
 #include <boost/python.hpp>
diff --git a/bindings/python/mapnik_parameters.cpp b/bindings/python/mapnik_parameters.cpp
index 5a015c0ae..1bc7d853a 100644
--- a/bindings/python/mapnik_parameters.cpp
+++ b/bindings/python/mapnik_parameters.cpp
@@ -25,6 +25,7 @@
 #include <boost/make_shared.hpp>
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/params.hpp>
 #include <mapnik/unicode.hpp>
 #include <mapnik/value.hpp>
@@ -102,7 +103,9 @@ struct parameters_pickle_suite : boost::python::pickle_suite
             }
             else
             {
-                std::clog <<  "could not unpickle key: " << key << "\n";
+#ifdef MAPNIK_LOG
+                mapnik::log() << "parameters_pickle_suite: Could not unpickle key=" << key;
+#endif
             }
         }
     }
diff --git a/bindings/python/mapnik_point_symbolizer.cpp b/bindings/python/mapnik_point_symbolizer.cpp
index ddd10bf41..2ca6c9acb 100644
--- a/bindings/python/mapnik_point_symbolizer.cpp
+++ b/bindings/python/mapnik_point_symbolizer.cpp
@@ -19,7 +19,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 #include <boost/python.hpp>
 #include "mapnik_enumeration.hpp"
diff --git a/bindings/python/mapnik_polygon_pattern_symbolizer.cpp b/bindings/python/mapnik_polygon_pattern_symbolizer.cpp
index 6aee342b8..dc155c5f6 100644
--- a/bindings/python/mapnik_polygon_pattern_symbolizer.cpp
+++ b/bindings/python/mapnik_polygon_pattern_symbolizer.cpp
@@ -19,7 +19,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 #include <boost/python.hpp>
 #include <mapnik/image_util.hpp>
diff --git a/bindings/python/mapnik_polygon_symbolizer.cpp b/bindings/python/mapnik_polygon_symbolizer.cpp
index dd809ac5d..06f35f0d8 100644
--- a/bindings/python/mapnik_polygon_symbolizer.cpp
+++ b/bindings/python/mapnik_polygon_symbolizer.cpp
@@ -19,7 +19,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 #include <boost/python.hpp>
 #include "mapnik_enumeration.hpp"
diff --git a/bindings/python/mapnik_proj_transform.cpp b/bindings/python/mapnik_proj_transform.cpp
index ed5e7c9a0..7dec3b36b 100644
--- a/bindings/python/mapnik_proj_transform.cpp
+++ b/bindings/python/mapnik_proj_transform.cpp
@@ -19,10 +19,10 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 // mapnik
 #include <mapnik/proj_transform.hpp>
+
 // boost
 #include <boost/python.hpp>
 
diff --git a/bindings/python/mapnik_projection.cpp b/bindings/python/mapnik_projection.cpp
index f555ab11a..54fba845f 100644
--- a/bindings/python/mapnik_projection.cpp
+++ b/bindings/python/mapnik_projection.cpp
@@ -19,9 +19,8 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
-//boost
+// boost
 #include <boost/python.hpp>
 
 // mapnik
diff --git a/bindings/python/mapnik_query.cpp b/bindings/python/mapnik_query.cpp
index 08133b17a..f2b5c368f 100644
--- a/bindings/python/mapnik_query.cpp
+++ b/bindings/python/mapnik_query.cpp
@@ -19,11 +19,14 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
+// boost
 #include <boost/python.hpp>
+
+// mapnik
 #include <mapnik/query.hpp>
 #include <mapnik/box2d.hpp>
+
 using mapnik::query;
 using mapnik::box2d;
 
diff --git a/bindings/python/mapnik_raster_colorizer.cpp b/bindings/python/mapnik_raster_colorizer.cpp
index 0aa43b3f2..7d9d6b755 100644
--- a/bindings/python/mapnik_raster_colorizer.cpp
+++ b/bindings/python/mapnik_raster_colorizer.cpp
@@ -19,10 +19,12 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
+// boost
 #include <boost/python.hpp>
 #include <boost/python/suite/indexing/vector_indexing_suite.hpp>
+
+// mapnik
 #include <mapnik/raster_colorizer.hpp>
 
 using mapnik::raster_colorizer;
diff --git a/bindings/python/mapnik_raster_symbolizer.cpp b/bindings/python/mapnik_raster_symbolizer.cpp
index 63a18b851..dacaea5de 100644
--- a/bindings/python/mapnik_raster_symbolizer.cpp
+++ b/bindings/python/mapnik_raster_symbolizer.cpp
@@ -19,9 +19,11 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
+// boost
 #include <boost/python.hpp>
+
+// mapnik
 #include <mapnik/raster_symbolizer.hpp>
 
 using mapnik::raster_symbolizer;
diff --git a/bindings/python/mapnik_rule.cpp b/bindings/python/mapnik_rule.cpp
index 528a87a63..378e22f10 100644
--- a/bindings/python/mapnik_rule.cpp
+++ b/bindings/python/mapnik_rule.cpp
@@ -19,13 +19,14 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
+// boost
 #include <boost/python.hpp>
 #include <boost/python/implicit.hpp>
 #include <boost/python/detail/api_placeholder.hpp>
 #include <boost/python/suite/indexing/vector_indexing_suite.hpp>
 
+// mapnik
 #include <mapnik/rule.hpp>
 #include <mapnik/expression.hpp>
 #include <mapnik/expression_string.hpp>
diff --git a/bindings/python/mapnik_shield_symbolizer.cpp b/bindings/python/mapnik_shield_symbolizer.cpp
index 41eff7536..28ae7083e 100644
--- a/bindings/python/mapnik_shield_symbolizer.cpp
+++ b/bindings/python/mapnik_shield_symbolizer.cpp
@@ -20,9 +20,11 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
+// boost
 #include <boost/python.hpp>
+
+// mapnik
 #include <mapnik/shield_symbolizer.hpp>
 #include <mapnik/image_util.hpp>
 #include <mapnik/path_expression_grammar.hpp>
diff --git a/bindings/python/mapnik_stroke.cpp b/bindings/python/mapnik_stroke.cpp
index a75f614c6..1f21071c3 100644
--- a/bindings/python/mapnik_stroke.cpp
+++ b/bindings/python/mapnik_stroke.cpp
@@ -19,7 +19,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 // boost
 #include <boost/python.hpp>
diff --git a/bindings/python/mapnik_style.cpp b/bindings/python/mapnik_style.cpp
index 1ab130c04..9437e87d5 100644
--- a/bindings/python/mapnik_style.cpp
+++ b/bindings/python/mapnik_style.cpp
@@ -19,11 +19,12 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
+// boost
 #include <boost/python.hpp>
 #include <boost/python/suite/indexing/vector_indexing_suite.hpp>
 
+// mapnik
 #include "mapnik_enumeration.hpp"
 #include <mapnik/feature_type_style.hpp>
 
diff --git a/bindings/python/mapnik_symbolizer.cpp b/bindings/python/mapnik_symbolizer.cpp
index a4c4c3512..bd87b0db8 100644
--- a/bindings/python/mapnik_symbolizer.cpp
+++ b/bindings/python/mapnik_symbolizer.cpp
@@ -19,10 +19,11 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
+// boost
 #include <boost/python.hpp>
 
+// mapnik
 //symbolizer typdef here rather than mapnik/symbolizer.hpp
 #include <mapnik/rule.hpp>
 
diff --git a/bindings/python/mapnik_view_transform.cpp b/bindings/python/mapnik_view_transform.cpp
index 7a9da32d5..090e65f9c 100644
--- a/bindings/python/mapnik_view_transform.cpp
+++ b/bindings/python/mapnik_view_transform.cpp
@@ -19,7 +19,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 // boost
 #include <boost/python.hpp>
diff --git a/bindings/python/python_cairo.cpp b/bindings/python/python_cairo.cpp
index e5420c1b1..ee6c900c3 100644
--- a/bindings/python/python_cairo.cpp
+++ b/bindings/python/python_cairo.cpp
@@ -19,7 +19,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 #if defined(HAVE_CAIRO) && defined(HAVE_PYCAIRO)
 
diff --git a/bindings/python/python_grid_utils.hpp b/bindings/python/python_grid_utils.hpp
index 09b72573c..2a9b21cf4 100644
--- a/bindings/python/python_grid_utils.hpp
+++ b/bindings/python/python_grid_utils.hpp
@@ -28,6 +28,7 @@
 #include <boost/foreach.hpp>
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/grid/grid_renderer.hpp>
 #include <mapnik/grid/grid.hpp>
 #include <mapnik/grid/grid_util.hpp>
@@ -271,7 +272,9 @@ static void write_features(T const& grid_type,
         }
         else
         {
-            std::clog << "should not get here: key '" << key << "' not found in grid feature properties\n";
+#ifdef MAPNIK_LOG
+            mapnik::log() << "write_features: Should not get here: key " << key << " not found in grid feature properties";
+#endif
         }
     }
 }
diff --git a/bindings/python/python_optional.hpp b/bindings/python/python_optional.hpp
index 7707f0053..29c1990db 100644
--- a/bindings/python/python_optional.hpp
+++ b/bindings/python/python_optional.hpp
@@ -19,7 +19,6 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 #include <boost/optional/optional.hpp>
 #include <boost/python.hpp>
diff --git a/include/mapnik/ctrans.hpp b/include/mapnik/ctrans.hpp
index 31c62f391..2d8423d85 100644
--- a/include/mapnik/ctrans.hpp
+++ b/include/mapnik/ctrans.hpp
@@ -24,6 +24,7 @@
 #define MAPNIK_CTRANS_HPP
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/box2d.hpp>
 #include <mapnik/vertex.hpp>
 #include <mapnik/coord_array.hpp>
@@ -239,9 +240,9 @@ struct MAPNIK_DECL coord_transform_parallel
                     angle_a = atan2((m_pre_y-m_cur_y),(m_pre_x-m_cur_x));
                     dx_pre = cos(angle_a + pi_by_2);
                     dy_pre = sin(angle_a + pi_by_2);
-#ifdef MAPNIK_DEBUG
-                    std::clog << "offsetting line by: " << offset_ << "\n";
-                    std::clog << "initial dx=" << (dx_pre * offset_) << " dy=" << (dy_pre * offset_) << "\n";
+#ifdef MAPNIK_LOG
+                    mapnik::log() << "coord_transform_parallel: Offsetting line by=" << offset_;
+                    mapnik::log() << "coord_transform_parallel: Initial dx=" << (dx_pre * offset_) << ",dy=" << (dy_pre * offset_);
 #endif
                     *x = m_pre_x + (dx_pre * offset_);
                     *y = m_pre_y + (dy_pre * offset_);
@@ -290,14 +291,14 @@ struct MAPNIK_DECL coord_transform_parallel
                     else // skip sharp spikes
                     {
 
-#ifdef MAPNIK_DEBUG
+#ifdef MAPNIK_LOG
                         dx_curr = cos(angle_a + pi_by_2);
                         dy_curr = sin(angle_a + pi_by_2);
                         sin_curve = dx_curr*dy_pre-dy_curr*dx_pre;
-                        std::clog << "angle a: " << angle_a << "\n";
-                        std::clog << "angle b: " << angle_b << "\n";
-                        std::clog << "h: " << h << "\n";
-                        std::clog << "sin_curve: " << sin_curve << "\n";
+                        mapnik::log() << "coord_transform_parallel: angle a=" << angle_a;
+                        mapnik::log() << "coord_transform_parallel: angle b=" << angle_b;
+                        mapnik::log() << "coord_transform_parallel: h=" << h;
+                        mapnik::log() << "coord_transform_parallel: sin_curve=" << sin_curve;
 #endif
                         m_status = process;
                         break;
@@ -309,21 +310,21 @@ struct MAPNIK_DECL coord_transform_parallel
                       sin_curve = dx_curr*dy_pre-dy_curr*dx_pre;
                       cos_curve = -dx_pre*dx_curr-dy_pre*dy_curr;
 
-                      #ifdef MAPNIK_DEBUG
-                      std::clog << "sin_curve value: " << sin_curve << "\n";
+                      #ifdef MAPNIK_LOG
+                        mapnik::log() << "coord_transform_parallel: sin_curve value=" << sin_curve;
                       #endif
                       if(sin_curve > -0.3 && sin_curve < 0.3) {
-                      angle_b = atan2((m_cur_y-m_next_y),(m_cur_x-m_next_x));
-                      h = tan((angle_b - angle_a)/2.0);
-                      *x = m_cur_x + (dx_curr * offset_) - h * (dy_curr * offset_);
-                      *y = m_cur_y + (dy_curr * offset_) + h * (dx_curr * offset_);
+                        angle_b = atan2((m_cur_y-m_next_y),(m_cur_x-m_next_x));
+                        h = tan((angle_b - angle_a)/2.0);
+                        *x = m_cur_x + (dx_curr * offset_) - h * (dy_curr * offset_);
+                        *y = m_cur_y + (dy_curr * offset_) + h * (dx_curr * offset_);
                       } else {
-                      if (angle_b - angle_a > 0)
-                      h = -1.0*(1.0+cos_curve)/sin_curve;
-                      else
-                      h = (1.0+cos_curve)/sin_curve;
-                      *x = m_cur_x + (dx_curr + base_shift*dy_curr)*offset_;
-                      *y = m_cur_y + (dy_curr - base_shift*dx_curr)*offset_;
+                        if (angle_b - angle_a > 0)
+                          h = -1.0*(1.0+cos_curve)/sin_curve;
+                        else
+                          h = (1.0+cos_curve)/sin_curve;
+                        *x = m_cur_x + (dx_curr + base_shift*dy_curr)*offset_;
+                        *y = m_cur_y + (dy_curr - base_shift*dx_curr)*offset_;
                       }
                     */
 
diff --git a/include/mapnik/datasource.hpp b/include/mapnik/datasource.hpp
index 6ae828a94..0e7b71f7c 100644
--- a/include/mapnik/datasource.hpp
+++ b/include/mapnik/datasource.hpp
@@ -88,6 +88,7 @@ public:
 
     datasource (parameters const& params)
       : params_(params),
+        log_enabled_(false),
         is_bound_(false)
     {
     }
@@ -104,6 +105,15 @@ 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)
@@ -123,6 +133,7 @@ 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
new file mode 100644
index 000000000..3abe24538
--- /dev/null
+++ b/include/mapnik/debug.hpp
@@ -0,0 +1,127 @@
+/*****************************************************************************
+ *
+ * This file is part of Mapnik (c++ mapping toolkit)
+ *
+ * Copyright (C) 2011 Artem Pavlenko
+ *
+ * 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
+ *
+ *****************************************************************************/
+
+#ifndef MAPNIK_DEBUG_HPP
+#define MAPNIK_DEBUG_HPP
+
+// mapnik
+#include <mapnik/global.hpp>
+
+// boost
+#ifdef MAPNIK_THREADSAFE
+#include <boost/thread/mutex.hpp>
+#endif
+
+// std
+#include <iostream>
+#include <cassert>
+#include <sstream>
+#include <ctime>
+#include <ostream>
+#include <fstream>
+
+#ifdef MAPNIK_DEBUG
+#define MAPNIK_DEBUG_AS_BOOL true
+#else
+#define MAPNIK_DEBUG_AS_BOOL false
+#endif
+
+#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 {
+
+#define __xstr__(s) __str__(s)
+#define __str__(s) #s
+
+        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));
+            return buf;
+        }
+
+#undef __xstr__
+#undef __str__
+
+        template<class Ch, class Tr, class A>
+        class no_output {
+        private:
+            struct null_buffer {
+                template<class T>
+                null_buffer &operator<<(const T &) {
+                    return *this;
+                }
+            };
+        public:
+            typedef null_buffer stream_buffer;
+
+        public:
+            void operator()(const stream_buffer &) {
+            }
+        };
+
+        template<class Ch, class Tr, class A>
+        class output_to_clog {
+        public:
+            typedef std::basic_ostringstream<Ch, Tr, A> stream_buffer;
+        public:
+            void operator()(const stream_buffer &s) {
+#ifdef MAPNIK_THREADSAFE
+                static boost::mutex mutex;
+                boost::mutex::scoped_lock lock(mutex);
+#endif
+                std::clog << format_logger() << " " << s.str() << std::endl;
+            }
+        };
+
+        template<template <class Ch, class Tr, class A> class OutputPolicy,
+                 class Ch = char,
+                 class Tr = std::char_traits<Ch>,
+                 class A = std::allocator<Ch> >
+        class base_log {
+            typedef OutputPolicy<Ch, Tr, A> output_policy;
+        public:
+            ~base_log() {
+                output_policy()(streambuf_);
+            }
+        public:
+            template<class T>
+            base_log &operator<<(const T &x) {
+                streambuf_ << x;
+                return *this;
+            }
+        private:
+            typename output_policy::stream_buffer streambuf_;
+        };
+    }
+
+    class log : public logger::base_log<logger::output_to_clog>
+    {
+    };
+
+}
+
+#endif
diff --git a/include/mapnik/font_engine_freetype.hpp b/include/mapnik/font_engine_freetype.hpp
index a08a6454d..8865faa49 100644
--- a/include/mapnik/font_engine_freetype.hpp
+++ b/include/mapnik/font_engine_freetype.hpp
@@ -24,6 +24,7 @@
 #define MAPNIK_FONT_ENGINE_FREETYPE_HPP
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/color.hpp>
 #include <mapnik/utils.hpp>
 #include <mapnik/ctrans.hpp>
@@ -138,9 +139,8 @@ public:
 
     ~font_face()
     {
-#ifdef MAPNIK_DEBUG
-        std::clog << "~font_face: Clean up face \"" << family_name()
-                  << " " << style_name() << "\"" << std::endl;
+#ifdef MAPNIK_LOG
+        mapnik::log() << "font_face: Clean up face \"" << family_name() << " " << style_name() << "\"";
 #endif
         FT_Done_Face(face_);
     }
@@ -225,9 +225,10 @@ public:
 
     ~stroker()
     {
-#ifdef MAPNIK_DEBUG
-        std::clog << "~stroker: destroy stroker:" << s_ << std::endl;
+#ifdef MAPNIK_LOG
+        mapnik::log() << "stroker: Destroy stroker=" << s_;
 #endif
+
         FT_Stroker_Done(s_);
     }
 private:
@@ -310,6 +311,7 @@ public:
                 face_set->add(face);
             } else {
 #ifdef MAPNIK_DEBUG
+                // TODO - handle with mapnik::log
                 std::cerr << "Failed to find face '" << *name << "' in font set '" << fset.get_name() << "'\n";
 #endif
             }
diff --git a/include/mapnik/grid/grid.hpp b/include/mapnik/grid/grid.hpp
index 0b1807c1c..d2e6e0986 100644
--- a/include/mapnik/grid/grid.hpp
+++ b/include/mapnik/grid/grid.hpp
@@ -25,6 +25,7 @@
 
 // mapnik
 #include <mapnik/config.hpp>
+#include <mapnik/debug.hpp>
 #include <mapnik/image_data.hpp>
 #include <mapnik/box2d.hpp>
 #include <mapnik/grid/grid_view.hpp>
@@ -72,7 +73,6 @@ private:
 
 public:
 
-
     hit_grid(int width, int height, std::string const& key, unsigned int resolution)
         :width_(width),
         height_(height),
@@ -136,7 +136,9 @@ public:
             }
             else
             {
-                std::clog << "should not get here: key '" << key_ << "' not found in feature properties\n";
+#ifdef MAPNIK_LOG
+                mapnik::log() << "hit_grid: Should not get here: key '" << key_ << "' not found in feature properties";
+#endif
             }
         }
 
@@ -153,7 +155,9 @@ public:
         }
         else
         {
-            std::clog << "### Warning: key '" << key_ << "' was blank for " << *feature << "\n";
+#ifdef MAPNIK_LOG
+            mapnik::log() << "hit_grid: Warning - key '" << key_ << "' was blank for " << *feature;
+#endif
         }
     }
 
diff --git a/include/mapnik/json/feature_collection_grammar.hpp b/include/mapnik/json/feature_collection_grammar.hpp
index 9117b14a7..37cddf1f6 100644
--- a/include/mapnik/json/feature_collection_grammar.hpp
+++ b/include/mapnik/json/feature_collection_grammar.hpp
@@ -103,7 +103,7 @@ struct feature_collection_grammar :
         qi::on_error<qi::fail>
             (
                 feature_collection
-                , std::clog
+                , std::cerr
                 << phoenix::val("Error parsing GeoJSON ")
                 << qi::_4                       
                 << phoenix::val(" here: \"")
diff --git a/include/mapnik/memory_featureset.hpp b/include/mapnik/memory_featureset.hpp
index 6e26c6ccb..91dd65782 100644
--- a/include/mapnik/memory_featureset.hpp
+++ b/include/mapnik/memory_featureset.hpp
@@ -24,6 +24,7 @@
 #define MAPNIK_MEMORY_FEATURESET_HPP
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/memory_datasource.hpp>
 
 // boost
@@ -52,10 +53,11 @@ public:
     {
         while (pos_ != end_)
         {
-            for  (unsigned i=0; i<(*pos_)->num_geometries();++i) {
+            for  (unsigned i=0; i<(*pos_)->num_geometries();++i)
+            {
                 geometry_type & geom = (*pos_)->get_geometry(i);
-#ifdef MAPNIK_DEBUG
-                std::clog << "bbox_=" << bbox_ << ", geom.envelope=" << geom.envelope() << "\n";
+#ifdef MAPNIK_LOG
+                mapnik::log() << "memory_featureset: BBox=" << bbox_ << ",Envelope=" << geom.envelope();
 #endif
                 if (bbox_.intersects(geom.envelope()))
                 {
diff --git a/include/mapnik/metawriter_json.hpp b/include/mapnik/metawriter_json.hpp
index 1a51b7609..045c3ef73 100644
--- a/include/mapnik/metawriter_json.hpp
+++ b/include/mapnik/metawriter_json.hpp
@@ -87,7 +87,7 @@ protected:
     bool pixel_coordinates_;
     virtual void write_header();
     inline void write_feature_header(std::string type) {
-#ifdef MAPNIK_DEBUG
+#ifdef MAPNIK_LOG
         if (count_ == STOPPED)
         {
             std::cerr << "WARNING: Metawriter not started before using it.\n";
diff --git a/include/mapnik/pool.hpp b/include/mapnik/pool.hpp
index 26fa2d520..8e6a5619c 100644
--- a/include/mapnik/pool.hpp
+++ b/include/mapnik/pool.hpp
@@ -24,6 +24,7 @@
 #define MAPNIK_POOL_HPP
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/utils.hpp>
 
 // boost
@@ -100,8 +101,8 @@ public:
         typename ContType::iterator itr=unusedPool_.begin();
         while ( itr!=unusedPool_.end())
         {
-#ifdef MAPNIK_DEBUG
-            std::clog<<"borrow "<<(*itr).get()<<"\n";
+#ifdef MAPNIK_LOG
+            mapnik::log() << "pool: Borrow instance=" << (*itr).get();
 #endif
             if ((*itr)->isOK())
             {
@@ -111,8 +112,8 @@ public:
             }
             else
             {
-#ifdef MAPNIK_DEBUG
-                std::clog<<"bad connection (erase)" << (*itr).get()<<"\n";
+#ifdef MAPNIK_LOG
+                mapnik::log() << "pool: Bad connection (erase) instance=" << (*itr).get();
 #endif
                 itr=unusedPool_.erase(itr);
             }
@@ -123,8 +124,8 @@ public:
             if (conn->isOK())
             {
                 usedPool_.push_back(conn);
-#ifdef MAPNIK_DEBUG
-                std::clog << "create << " << conn.get() << "\n";
+#ifdef MAPNIK_LOG
+                mapnik::log() << "pool: Create connection=" << conn.get();
 #endif
                 return conn;
             }
@@ -142,8 +143,8 @@ public:
         {
             if (obj.get()==(*itr).get())
             {
-#ifdef MAPNIK_DEBUG
-                std::clog<<"return "<<(*itr).get()<<"\n";
+#ifdef MAPNIK_LOG
+                mapnik::log() << "pool: Return instance=" << (*itr).get();
 #endif
                 unusedPool_.push_back(*itr);
                 usedPool_.erase(itr);
diff --git a/include/mapnik/rule.hpp b/include/mapnik/rule.hpp
index 23cf62a0d..a0e625603 100644
--- a/include/mapnik/rule.hpp
+++ b/include/mapnik/rule.hpp
@@ -203,7 +203,7 @@ private:
         template <class T>
         void copy_text_ptr(T & sym) const
         {
-#ifdef MAPNIK_DEBUG
+#ifdef MAPNIK_LOG
             std::cerr << "Warning: Deep copying TextSymbolizers is broken!\n";
 #endif
         }
diff --git a/include/mapnik/svg/svg_renderer.hpp b/include/mapnik/svg/svg_renderer.hpp
index aa2743ec1..391d4b8c4 100644
--- a/include/mapnik/svg/svg_renderer.hpp
+++ b/include/mapnik/svg/svg_renderer.hpp
@@ -24,6 +24,7 @@
 #define MAPNIK_SVG_RENDERER_HPP
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/svg/svg_path_attributes.hpp>
 #include <mapnik/gradient.hpp>
 #include <mapnik/box2d.hpp>
@@ -141,11 +142,13 @@ public:
         BOOST_FOREACH ( mapnik::stop_pair const& st, grad.get_stop_array() )
         {
             mapnik::color const& stop_color = st.second;
-            unsigned r= stop_color.red();
-            unsigned g= stop_color.green();
-            unsigned b= stop_color.blue();
-            unsigned a= stop_color.alpha();
-            //std::clog << "r: " << r << " g: " << g << " b: " << b << "a: " << a << "\n";
+            unsigned r = stop_color.red();
+            unsigned g = stop_color.green();
+            unsigned b = stop_color.blue();
+            unsigned a = stop_color.alpha();
+#ifdef MAPNIK_LOG
+            //mapnik::log() << "svg_renderer: r=" << r << ",g=" << g << ",b=" << b << ",a=" << a;
+#endif
             m_gradient_lut.add_color(st.first, agg::rgba8(r, g, b, int(a * opacity)));
         }
         m_gradient_lut.build_lut();
diff --git a/include/mapnik/timer.hpp b/include/mapnik/timer.hpp
index 8122aad85..9a019bc08 100644
--- a/include/mapnik/timer.hpp
+++ b/include/mapnik/timer.hpp
@@ -30,8 +30,34 @@
 #include <iomanip>
 #include <ctime>
 
+#ifndef WIN32
+#include <sys/time.h> // for gettimeofday() on unix
+#include <sys/resource.h>
+#else
+#include <windows.h>
+#endif
+
+
 namespace mapnik {
 
+
+// Try to return the time now
+inline double time_now()
+{
+#ifndef WIN32
+    struct timeval t;
+    struct timezone tzp;
+    gettimeofday(&t, &tzp);
+    return t.tv_sec + t.tv_usec * 1e-6;
+#else
+    LARGE_INTEGER t, f;
+    QueryPerformanceCounter(&t);
+    QueryPerformanceFrequency(&f);
+    return double(t.QuadPart) / double(f.QuadPart);
+#endif
+}
+
+
 // Measure times in both wall clock time and CPU times. Results are returned in milliseconds.
 class timer
 {
@@ -41,44 +67,50 @@ public:
         restart();
     }
 
+    virtual ~timer()
+    {
+    }
+
     void restart()
     {
-        _stopped = false;
-        gettimeofday(&_wall_clock_start, NULL);
-        _cpu_start = clock();
+        stopped_ = false;
+        wall_clock_start_ = time_now();
+        cpu_start_ = clock();
     }
 
     virtual void stop() const
     {
-        _stopped = true;
-        _cpu_end = clock();
-        gettimeofday(&_wall_clock_end, NULL);
+        stopped_ = true;
+        cpu_end_ = clock();
+        wall_clock_end_ = time_now();
     }
 
     double cpu_elapsed() const
     {
         // return elapsed CPU time in ms
-        if (!_stopped)
+        if (! stopped_)
+        {
             stop();
+        }
 
-        return ((double) (_cpu_end - _cpu_start)) / CLOCKS_PER_SEC * 1000.0;
+        return ((double) (cpu_end_ - cpu_start_)) / CLOCKS_PER_SEC * 1000.0;
     }
 
     double wall_clock_elapsed() const
     {
         // return elapsed wall clock time in ms
-        if (!_stopped)
+        if (! stopped_)
+        {
             stop();
+        }
 
-        long seconds  = _wall_clock_end.tv_sec  - _wall_clock_start.tv_sec;
-        long useconds = _wall_clock_end.tv_usec - _wall_clock_start.tv_usec;
-
-        return ((seconds) * 1000 + useconds / 1000.0) + 0.5;
+        return (wall_clock_end_ - wall_clock_start_) * 1000.0;
     }
+
 protected:
-    mutable timeval _wall_clock_start, _wall_clock_end;
-    mutable clock_t _cpu_start, _cpu_end;
-    mutable bool _stopped;
+    mutable double wall_clock_start_, wall_clock_end_;
+    mutable clock_t cpu_start_, cpu_end_;
+    mutable bool stopped_;
 };
 
 //  A progress_timer behaves like a timer except that the destructor displays
@@ -86,15 +118,17 @@ protected:
 class progress_timer : public timer
 {
 public:
-    progress_timer(std::ostream & os, std::string const& base_message):
-        os_(os),
-        base_message_(base_message)
+    progress_timer(std::ostream & os, std::string const& base_message)
+        : os_(os),
+          base_message_(base_message)
     {}
 
     ~progress_timer()
     {
-        if (!_stopped)
+        if (! stopped_)
+        {
             stop();
+        }
     }
 
     void stop() const
@@ -112,8 +146,9 @@ public:
         catch (...) {} // eat any exceptions
     }
 
-    void discard() {
-        _stopped = true;
+    void discard()
+    {
+        stopped_ = true;
     }
 
 private:
@@ -122,4 +157,5 @@ private:
 };
 
 };
+
 #endif // MAPNIK_TIMER_HPP
diff --git a/include/mapnik/utils.hpp b/include/mapnik/utils.hpp
index d7d342477..822273921 100644
--- a/include/mapnik/utils.hpp
+++ b/include/mapnik/utils.hpp
@@ -23,10 +23,14 @@
 #ifndef MAPNIK_UTILS_HPP
 #define MAPNIK_UTILS_HPP
 
+// boost
 #ifdef MAPNIK_THREADSAFE
 #include <boost/thread/mutex.hpp>
 #endif
 
+// mapnik
+#include <mapnik/debug.hpp>
+
 // stl
 #include <stdexcept>
 #include <cstdlib>
@@ -86,7 +90,7 @@ public:
     // Sun C++ Compiler doesn't handle `volatile` keyword same as GCC.
     static void destroy(T* obj)
 #else
-        static void destroy(volatile T* obj)
+    static void destroy(volatile T* obj)
 #endif
     {
         obj->~T();
@@ -109,6 +113,7 @@ template <typename T,
     static bool destroyed_;
     singleton(const singleton &rhs);
     singleton& operator=(const singleton&);
+
     static void onDeadReference()
     {
         throw std::runtime_error("dead reference!");
@@ -119,8 +124,9 @@ template <typename T,
         CreatePolicy<T>::destroy(pInstance_);
         pInstance_ = 0;
         destroyed_=true;
-#ifdef MAPNIK_DEBUG
-        std::clog << " destroyed singleton \n";
+
+#ifdef MAPNIK_LOG
+        mapnik::log() << "singleton: Destroyed instance";
 #endif
     }
 
@@ -132,21 +138,25 @@ protected:
 public:
     static  T* instance()
     {
-        if (!pInstance_)
+        if (! pInstance_)
         {
 #ifdef MAPNIK_THREADSAFE
             mutex::scoped_lock lock(mutex_);
 #endif
-            if (!pInstance_)
+            if (! pInstance_)
             {
-
                 if (destroyed_)
                 {
                     onDeadReference();
                 }
                 else
                 {
-                    pInstance_=CreatePolicy<T>::create();
+                    pInstance_ = CreatePolicy<T>::create();
+
+#ifdef MAPNIK_LOG
+                    mapnik::log() << "singleton: Created instance";
+#endif
+
                     // register destruction
                     std::atexit(&DestroySingleton);
                 }
diff --git a/plugins/input/csv/csv_datasource.cpp b/plugins/input/csv/csv_datasource.cpp
index dc0b27c5e..4a65c8000 100644
--- a/plugins/input/csv/csv_datasource.cpp
+++ b/plugins/input/csv/csv_datasource.cpp
@@ -1,3 +1,25 @@
+/*****************************************************************************
+ *
+ * This file is part of Mapnik (c++ mapping toolkit)
+ *
+ * Copyright (C) 2011 Artem Pavlenko
+ *
+ * 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 "csv_datasource.hpp"
 
 // boost
@@ -9,6 +31,7 @@
 #include <boost/spirit/include/phoenix_operator.hpp>
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/feature_layer_desc.hpp>
 #include <mapnik/feature_factory.hpp>
 #include <mapnik/geometry.hpp>
@@ -31,24 +54,26 @@ using namespace boost::spirit;
 DATASOURCE_PLUGIN(csv_datasource)
 
 csv_datasource::csv_datasource(parameters const& params, bool bind)
-: datasource(params),
-    desc_(*params_.get<std::string>("type"), *params_.get<std::string>("encoding", "utf-8")),
-    extent_(),
-    filename_(),
-    inline_string_(),
-    file_length_(0),
-    row_limit_(*params_.get<int>("row_limit", 0)),
-    features_(),
-    escape_(*params_.get<std::string>("escape", "")),
-    separator_(*params_.get<std::string>("separator", "")),
-    quote_(*params_.get<std::string>("quote", "")),
-    headers_(),
-    manual_headers_(boost::trim_copy(*params_.get<std::string>("headers", ""))),
-    strict_(*params_.get<mapnik::boolean>("strict", false)),
-    quiet_(*params_.get<mapnik::boolean>("quiet", false)),
-    filesize_max_(*params_.get<float>("filesize_max", 20.0)),  // MB
-    ctx_(boost::make_shared<mapnik::context_type>())
+    : datasource(params),
+      desc_(*params_.get<std::string>("type"), *params_.get<std::string>("encoding", "utf-8")),
+      extent_(),
+      filename_(),
+      inline_string_(),
+      file_length_(0),
+      row_limit_(*params_.get<int>("row_limit", 0)),
+      features_(),
+      escape_(*params_.get<std::string>("escape", "")),
+      separator_(*params_.get<std::string>("separator", "")),
+      quote_(*params_.get<std::string>("quote", "")),
+      headers_(),
+      manual_headers_(boost::trim_copy(*params_.get<std::string>("headers", ""))),
+      strict_(*params_.get<mapnik::boolean>("strict", false)),
+      quiet_(*params_.get<mapnik::boolean>("quiet", false)),
+      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
@@ -197,8 +222,9 @@ void csv_datasource::parse_csv(T& stream,
             if (num_tabs > num_commas)
             {
                 sep = "\t";
-#ifdef MAPNIK_DEBUG
-                std::clog << "CSV Plugin: auto detected tab separator\n";
+
+#ifdef MAPNIK_LOG
+                if (log_enabled_) mapnik::log() << "csv_datasource: auto detected tab separator";
 #endif
             }
         }
@@ -208,8 +234,9 @@ void csv_datasource::parse_csv(T& stream,
             if (num_pipes > num_commas)
             {
                 sep = "|";
-#ifdef MAPNIK_DEBUG
-                std::clog << "CSV Plugin: auto detected '|' separator\n";
+
+#ifdef MAPNIK_LOG
+                if (log_enabled_) mapnik::log() << "csv_datasource: auto detected '|' separator";
 #endif
             }
             else // semicolons
@@ -218,8 +245,9 @@ void csv_datasource::parse_csv(T& stream,
                 if (num_semicolons > num_commas)
                 {
                     sep = ";";
-#ifdef MAPNIK_DEBUG
-                    std::clog << "CSV Plugin: auto detected ';' separator\n";
+
+#ifdef MAPNIK_LOG
+                    if (log_enabled_) mapnik::log() << "csv_datasource: auto detected ';' separator";
 #endif
                 }
             }
@@ -237,8 +265,8 @@ void csv_datasource::parse_csv(T& stream,
     std::string quo = boost::trim_copy(quote);
     if (quo.empty()) quo = "\"";
 
-#ifdef MAPNIK_DEBUG
-    std::clog << "CSV Plugin: csv grammer: sep: '" << sep << "' quo: '" << quo << "' esc: '" << esc << "'\n";
+#ifdef MAPNIK_LOG
+    if (log_enabled_) mapnik::log() << "csv_datasource: csv grammer: sep: '" << sep << "' quo: '" << quo << "' esc: '" << esc;
 #endif
 
     boost::escaped_list_separator<char> grammer;
@@ -404,8 +432,8 @@ void csv_datasource::parse_csv(T& stream,
     {
         if ((row_limit_ > 0) && (line_number > row_limit_))
         {
-#ifdef MAPNIK_DEBUG
-            std::clog << "CSV Plugin: row limit hit, exiting at feature: " << feature_count << "\n";
+#ifdef MAPNIK_LOG
+            if (log_enabled_) mapnik::log() << "csv_datasource: row limit hit, exiting at feature: " << feature_count;
 #endif
             break;
         }
@@ -417,12 +445,15 @@ void csv_datasource::parse_csv(T& stream,
         {
             std::string trimmed = csv_line;
             boost::trim_if(trimmed,boost::algorithm::is_any_of("\",'\r\n"));
-            if (trimmed.empty()){
+            if (trimmed.empty())
+            {
                 ++line_number;
-                continue;
-#ifdef MAPNIK_DEBUG
-                std::clog << "CSV Plugin: empty row encountered at line: " << line_number << "\n";
+
+#ifdef MAPNIK_LOG
+                if (log_enabled_) mapnik::log() << "csv_datasource: empty row encountered at line: " << line_number;
 #endif
+
+                continue;
             }
         }
 
@@ -524,7 +555,8 @@ void csv_datasource::parse_csv(T& stream,
                                 }
                                 else
                                 {
-                                    if (!quiet_) std::clog << s.str() << "\n";
+                                    // TODO - handle this with mapnik::log
+                                    if (!quiet_) std::cerr << s.str() << "\n";
                                 }
                             }
                         }
@@ -548,7 +580,8 @@ void csv_datasource::parse_csv(T& stream,
                                 }
                                 else
                                 {
-                                    if (!quiet_) std::clog << s.str() << "\n";
+                                    // TODO - handle this with mapnik::log
+                                    if (!quiet_) std::cerr << s.str() << "\n";
                                 }
                             }
                         }
@@ -585,7 +618,8 @@ void csv_datasource::parse_csv(T& stream,
                             }
                             else
                             {
-                                if (!quiet_) std::clog << s.str() << "\n";
+                                // TODO - handle this with mapnik::log
+                                if (!quiet_) std::cerr << s.str() << "\n";
                             }
                         }
                     }
@@ -618,7 +652,8 @@ void csv_datasource::parse_csv(T& stream,
                             }
                             else
                             {
-                                if (!quiet_) std::clog << s.str() << "\n";
+                                // TODO - handle this with mapnik::log
+                                if (!quiet_) std::cerr << s.str() << "\n";
                             }
                         }
                     }
@@ -711,7 +746,8 @@ void csv_datasource::parse_csv(T& stream,
                 }
                 else
                 {
-                    if (!quiet_) std::clog << s.str() << "\n";
+                    // TODO - handle this with mapnik::log
+                    if (!quiet_) std::cerr << s.str() << "\n";
                     continue;
                 }
             }
@@ -744,7 +780,8 @@ void csv_datasource::parse_csv(T& stream,
                     }
                     else
                     {
-                        if (!quiet_) std::clog << s.str() << "\n";
+                        // TODO - handle this with mapnik::log
+                        if (!quiet_) std::cerr << s.str() << "\n";
                         continue;
                     }
                 }
@@ -795,7 +832,8 @@ void csv_datasource::parse_csv(T& stream,
                     }
                     else
                     {
-                        if (!quiet_) std::clog << s.str() << "\n";
+                        // TODO - handle this with mapnik::log
+                        if (!quiet_) std::cerr << s.str() << "\n";
                         continue;
                     }
                 }
@@ -810,7 +848,8 @@ void csv_datasource::parse_csv(T& stream,
             }
             else
             {
-                if (!quiet_) std::clog << ex.what() << "\n";
+                // TODO - handle this with mapnik::log
+                if (!quiet_) std::cerr << ex.what() << "\n";
             }
         }
         catch(const std::exception & ex)
@@ -825,13 +864,15 @@ void csv_datasource::parse_csv(T& stream,
             }
             else
             {
-                if (!quiet_) std::clog << s.str() << "\n";
+                // TODO - handle this with mapnik::log
+                if (!quiet_) std::cerr << s.str() << "\n";
             }
         }
     }
     if (!feature_count > 0)
     {
-        if (!quiet_) std::clog << "CSV Plugin: could not parse any lines of data\n";
+        // TODO - handle this with mapnik::log
+        if (!quiet_) std::cerr << "CSV Plugin: could not parse any lines of data\n";
     }
 }
 
diff --git a/plugins/input/csv/csv_datasource.hpp b/plugins/input/csv/csv_datasource.hpp
index 985d73242..86bcfd4f9 100644
--- a/plugins/input/csv/csv_datasource.hpp
+++ b/plugins/input/csv/csv_datasource.hpp
@@ -1,3 +1,25 @@
+/*****************************************************************************
+ *
+ * This file is part of Mapnik (c++ mapping toolkit)
+ *
+ * Copyright (C) 2011 Artem Pavlenko
+ *
+ * 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
+ *
+ *****************************************************************************/
+
 #ifndef MAPNIK_CSV_DATASOURCE_HPP
 #define MAPNIK_CSV_DATASOURCE_HPP
 
@@ -20,11 +42,13 @@ public:
     boost::optional<mapnik::datasource::geometry_t> get_geometry_type() const;
     mapnik::layer_descriptor get_descriptor() const;
     void bind() const;
+
     template <typename T>
     void parse_csv(T& stream,
                    std::string const& escape,
                    std::string const& separator,
                    std::string const& quote) const;
+
 private:
     mutable mapnik::layer_descriptor desc_;
     mutable mapnik::box2d<double> extent_;
@@ -44,5 +68,4 @@ private:
     mutable mapnik::context_ptr ctx_;
 };
 
-
 #endif // MAPNIK_CSV_DATASOURCE_HPP
diff --git a/plugins/input/gdal/gdal_datasource.cpp b/plugins/input/gdal/gdal_datasource.cpp
index 29303bd5e..9bf10dad3 100644
--- a/plugins/input/gdal/gdal_datasource.cpp
+++ b/plugins/input/gdal/gdal_datasource.cpp
@@ -25,8 +25,10 @@
 #include "gdal_featureset.hpp"
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/boolean.hpp>
 #include <mapnik/geom_util.hpp>
+#include <mapnik/timer.hpp>
 
 #include <gdal_version.h>
 
@@ -49,9 +51,8 @@ using mapnik::datasource_exception;
  */
 inline GDALDataset* gdal_datasource::open_dataset() const
 {
-
-#ifdef MAPNIK_DEBUG
-    std::clog << "GDAL Plugin: opening: " << dataset_name_ << std::endl;
+#ifdef MAPNIK_LOG
+    if (log_enabled_) mapnik::log() << "gdal_datasource: Opening " << dataset_name_;
 #endif
 
     GDALDataset *dataset;
@@ -81,8 +82,10 @@ gdal_datasource::gdal_datasource(parameters const& params, bool bind)
       filter_factor_(*params_.get<double>("filter_factor", 0.0)),
       nodata_value_(params_.get<double>("nodata"))
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "GDAL Plugin: Initializing..." << std::endl;
+    log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
+
+#ifdef MAPNIK_LOG
+    if (log_enabled_) mapnik::log() << "gdal_datasource: Initializing...";
 #endif
 
     GDALAllRegister();
@@ -110,6 +113,10 @@ void gdal_datasource::bind() const
 {
     if (is_bound_) return;
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "gdal_datasource::bind");
+#endif
+
     shared_dataset_ = *params_.get<mapnik::boolean>("shared", false);
     band_ = *params_.get<int>("band", -1);
 
@@ -124,8 +131,8 @@ void gdal_datasource::bind() const
     boost::optional<std::string> bbox_s = params_.get<std::string>("bbox");
     if (bbox_s)
     {
-#ifdef MAPNIK_DEBUG
-        std::clog << "GDAL Plugin: bbox parameter=" << *bbox_s << std::endl;
+#ifdef MAPNIK_LOG
+        if (log_enabled_) mapnik::log() << "gdal_datasource: BBox Parameter=" << *bbox_s;
 #endif
 
         bbox_override = extent_.from_string(*bbox_s);
@@ -149,10 +156,13 @@ void gdal_datasource::bind() const
         dataset->GetGeoTransform(tr);
     }
 
-#ifdef MAPNIK_DEBUG
-    std::clog << "GDAL Plugin: geotransform=" << tr[0] << "," << tr[1] << ","
-              << tr[2] << "," << tr[3] << ","
-              << tr[4] << "," << tr[5] << std::endl;
+#ifdef MAPNIK_LOG
+    if (log_enabled_)
+    {
+        mapnik::log() << "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
@@ -188,9 +198,12 @@ void gdal_datasource::bind() const
 
     GDALClose(dataset);
 
-#ifdef MAPNIK_DEBUG
-    std::clog << "GDAL Plugin: Raster Size=" << width_ << "," << height_ << std::endl;
-    std::clog << "GDAL Plugin: Raster Extent=" << extent_ << std::endl;
+#ifdef MAPNIK_LOG
+    if (log_enabled_)
+    {
+        mapnik::log() << "gdal_datasource: Raster Size=" << width_ << "," << height_;
+        mapnik::log() << "gdal_datasource: Raster Extent=" << extent_;
+    }
 #endif
 
     is_bound_ = true;
@@ -231,6 +244,10 @@ featureset_ptr gdal_datasource::features(query const& q) const
 {
     if (! is_bound_) bind();
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "gdal_datasource::features");
+#endif
+
     gdal_query gq = q;
 
     // TODO - move to boost::make_shared, but must reduce # of args to <= 9
@@ -251,6 +268,10 @@ featureset_ptr gdal_datasource::features_at_point(coord2d const& pt) const
 {
     if (! is_bound_) bind();
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "gdal_datasource::features_at_point");
+#endif
+
     gdal_query gq = pt;
 
     // TODO - move to boost::make_shared, but must reduce # of args to <= 9
diff --git a/plugins/input/gdal/gdal_datasource.hpp b/plugins/input/gdal/gdal_datasource.hpp
index 4b2d2ea9d..eb196ee28 100644
--- a/plugins/input/gdal/gdal_datasource.hpp
+++ b/plugins/input/gdal/gdal_datasource.hpp
@@ -46,6 +46,7 @@ public:
     mapnik::layer_descriptor get_descriptor() const;
     void bind() const;
 private:
+    GDALDataset* open_dataset() const;
     mutable mapnik::box2d<double> extent_;
     std::string dataset_name_;
     mutable int band_;
@@ -58,8 +59,6 @@ private:
     mutable bool shared_dataset_;
     double filter_factor_;
     boost::optional<double> nodata_value_;
-    inline GDALDataset* open_dataset() const;
 };
 
-
 #endif // GDAL_DATASOURCE_HPP
diff --git a/plugins/input/gdal/gdal_featureset.cpp b/plugins/input/gdal/gdal_featureset.cpp
index 14bf11ee5..18c5fdcaa 100644
--- a/plugins/input/gdal/gdal_featureset.cpp
+++ b/plugins/input/gdal/gdal_featureset.cpp
@@ -22,14 +22,15 @@
 
 // mapnik
 #include <mapnik/global.hpp>
+#include <mapnik/debug.hpp>
 #include <mapnik/feature_factory.hpp>
 
-#include "gdal_featureset.hpp"
-#include <gdal_priv.h>
-
 // boost
 #include <boost/format.hpp>
 
+#include "gdal_featureset.hpp"
+#include <gdal_priv.h>
+
 using mapnik::query;
 using mapnik::coord2d;
 using mapnik::box2d;
@@ -75,8 +76,8 @@ gdal_featureset::gdal_featureset(GDALDataset& dataset,
 
 gdal_featureset::~gdal_featureset()
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "GDAL Plugin: closing dataset = " << &dataset_ << std::endl;
+#ifdef MAPNIK_LOG
+    mapnik::log() << "gdal_featureset: Closing Dataset=" << &dataset_;
 #endif
 
     GDALClose(&dataset_);
@@ -87,8 +88,9 @@ feature_ptr gdal_featureset::next()
     if (first_)
     {
         first_ = false;
-#ifdef MAPNIK_DEBUG
-        std::clog << "GDAL Plugin: featureset, dataset = " << &dataset_ << std::endl;
+
+#ifdef MAPNIK_LOG
+        mapnik::log() << "gdal_featureset: Next feature in Dataset=" << &dataset_;
 #endif
 
         query *q = boost::get<query>(&gquery_);
@@ -125,7 +127,9 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
 
       double dx = tr[1];
       double dy = tr[5];
-      std::clog << "dx_: " << dx_ << " dx: " << dx << " dy_: " << dy_ << "dy: " << dy << "\n";
+#ifdef MAPNIK_DEBUG
+      mapnik::log() << "gdal_featureset: dx_=" << dx_ << " dx=" << dx << " dy_=" << dy_ << "dy=" << dy;
+#endif
     */
 
     CoordTransform t(raster_width_, raster_height_, raster_extent_, 0, 0);
@@ -184,11 +188,11 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
     box2d<double> feature_raster_extent(x_off, y_off, x_off + width, y_off + height);
     intersect = t.backward(feature_raster_extent);
 
-#ifdef MAPNIK_DEBUG
-    std::clog << "GDAL Plugin: Raster extent=" << raster_extent_ << std::endl;
-    std::clog << "GDAL Plugin: View extent=" << intersect << std::endl;
-    std::clog << "GDAL Plugin: Query resolution=" << boost::get<0>(q.resolution()) << "," << boost::get<1>(q.resolution()) << std::endl;
-    std::clog << boost::format("GDAL Plugin: StartX=%d StartY=%d Width=%d Height=%d") % x_off % y_off % width % height << std::endl;
+#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;
 #endif
 
     if (width > 0 && height > 0)
@@ -203,8 +207,9 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
         {
             im_width *= filter_factor_;
             im_height *= filter_factor_;
-#ifdef MAPNIK_DEBUG
-            std::clog << "GDAL Plugin: applying layer filter_factor: " << filter_factor_ << "\n";
+
+#ifdef MAPNIK_LOG
+            mapnik::log() << "gdal_featureset: Applying layer filter_factor=" << filter_factor_;
 #endif
         }
         // otherwise respect symbolizer level factor applied to query, default of 1.0
@@ -228,9 +233,9 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
             mapnik::image_data_32 image(im_width, im_height);
             image.set(0xffffffff);
 
-#ifdef MAPNIK_DEBUG
-            std::clog << "GDAL Plugin: Image Size=(" << im_width << "," << im_height << ")" << std::endl;
-            std::clog << "GDAL Plugin: Reading band " << band_ << std::endl;
+#ifdef MAPNIK_LOG
+            mapnik::log() << "gdal_featureset: Image Size=(" << im_width << "," << im_height << ")";
+            mapnik::log() << "gdal_featureset: Reading band=" << band_;
 #endif
             typedef std::vector<int,int> pallete;
 
@@ -270,7 +275,7 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
                 {
                     GDALRasterBand * band = dataset_.GetRasterBand(i + 1);
 
-#ifdef MAPNIK_DEBUG
+#ifdef MAPNIK_LOG
                     get_overview_meta(band);
 #endif
 
@@ -279,68 +284,68 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
                     {
                     case GCI_RedBand:
                         red = band;
-#ifdef MAPNIK_DEBUG
-                        std::clog << "GDAL Plugin: Found red band" << std::endl;
+#ifdef MAPNIK_LOG
+                        mapnik::log() << "gdal_featureset: Found red band";
 #endif
                         break;
                     case GCI_GreenBand:
                         green = band;
-#ifdef MAPNIK_DEBUG
-                        std::clog << "GDAL Plugin: Found green band" << std::endl;
+#ifdef MAPNIK_LOG
+                        mapnik::log() << "gdal_featureset: Found green band";
 #endif
                         break;
                     case GCI_BlueBand:
                         blue = band;
-#ifdef MAPNIK_DEBUG
-                        std::clog << "GDAL Plugin: Found blue band" << std::endl;
+#ifdef MAPNIK_LOG
+                        mapnik::log() << "gdal_featureset: Found blue band";
 #endif
                         break;
                     case GCI_AlphaBand:
                         alpha = band;
-#ifdef MAPNIK_DEBUG
-                        std::clog << "GDAL Plugin: Found alpha band" << std::endl;
+#ifdef MAPNIK_LOG
+                        mapnik::log() << "gdal_featureset: Found alpha band";
 #endif
                         break;
                     case GCI_GrayIndex:
                         grey = band;
-#ifdef MAPNIK_DEBUG
-                        std::clog << "GDAL Plugin: Found gray band" << std::endl;
+#ifdef MAPNIK_LOG
+                        mapnik::log() << "gdal_featureset: Found gray band";
 #endif
                         break;
                     case GCI_PaletteIndex:
                     {
                         grey = band;
-#ifdef MAPNIK_DEBUG
-                        std::clog << "GDAL Plugin: Found gray band, and colortable..." << std::endl;
+#ifdef MAPNIK_LOG
+                        mapnik::log() << "gdal_featureset: Found gray band, and colortable...";
 #endif
                         GDALColorTable *color_table = band->GetColorTable();
 
                         if (color_table)
                         {
                             int count = color_table->GetColorEntryCount();
-#ifdef MAPNIK_DEBUG
-                            std::clog << "GDAL Plugin: Color Table count = " << count << std::endl;
+#ifdef MAPNIK_LOG
+                            mapnik::log() << "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_DEBUG
-                                std::clog << "GDAL Plugin: Color entry RGB (" << ce->c1 << "," <<ce->c2 << "," << ce->c3 << ")" << std::endl;
+#ifdef MAPNIK_LOG
+                                mapnik::log() << "gdal_featureset: Color entry RGB=" << ce->c1 << "," <<ce->c2 << "," << ce->c3;
 #endif
                             }
                         }
                         break;
                     }
                     case GCI_Undefined:
-#ifdef MAPNIK_DEBUG
-                        std::clog << "GDAL Plugin: Found undefined band (assumming gray band)" << std::endl;
+#ifdef MAPNIK_LOG
+                        mapnik::log() << "gdal_featureset: Found undefined band (assumming gray band)";
 #endif
                         grey = band;
                         break;
                     default:
-#ifdef MAPNIK_DEBUG
-                        std::clog << "GDAL Plugin: band type unknown!" << std::endl;
+#ifdef MAPNIK_LOG
+                        mapnik::log() << "gdal_featureset: Band type unknown!";
 #endif
                         break;
                     }
@@ -348,8 +353,8 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
 
                 if (red && green && blue)
                 {
-#ifdef MAPNIK_DEBUG
-                    std::clog << "GDAL Plugin: processing rgb bands..." << std::endl;
+#ifdef MAPNIK_LOG
+                    mapnik::log() << "gdal_featureset: Processing rgb bands...";
 #endif
                     int hasNoData(0);
                     double nodata(0);
@@ -401,8 +406,8 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
                 }
                 else if (grey)
                 {
-#ifdef MAPNIK_DEBUG
-                    std::clog << "GDAL Plugin: processing gray band..." << std::endl;
+#ifdef MAPNIK_LOG
+                    mapnik::log() << "gdal_featureset: Processing gray band...";
 #endif
                     int hasNoData(0);
                     double nodata(0);
@@ -419,13 +424,10 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
 
                     if (hasNoData && ! color_table)
                     {
-                        if (hasNoData)
-                        {
-                            feature->put("NODATA",nodata);
-                        }
-#ifdef MAPNIK_DEBUG
-                        std::clog << "\tno data value for layer: " << nodata << std::endl;
+#ifdef MAPNIK_LOG
+                        mapnik::log() << "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
                         float* imageData = (float*)image.getBytes();
                         grey->RasterIO(GF_Read, x_off, y_off, width, height,
@@ -456,8 +458,8 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
 
                     if (color_table)
                     {
-#ifdef MAPNIK_DEBUG
-                        std::clog << "GDAL Plugin: Loading colour table..." << std::endl;
+#ifdef MAPNIK_LOG
+                        mapnik::log() << "gdal_featureset: Loading colour table...";
 #endif
                         unsigned nodata_value = static_cast<unsigned>(nodata);
                         if (hasNoData)
@@ -496,8 +498,8 @@ feature_ptr gdal_featureset::get_feature(mapnik::query const& q)
                 }
                 if (alpha)
                 {
-#ifdef MAPNIK_DEBUG
-                    std::clog << "GDAL Plugin: processing alpha band..." << std::endl;
+#ifdef MAPNIK_LOG
+                    mapnik::log() << "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());
@@ -533,9 +535,9 @@ feature_ptr gdal_featureset::get_feature_at_point(mapnik::coord2d const& pt)
 
         if (x < raster_xsize && y < raster_ysize)
         {
-#ifdef MAPNIK_DEBUG
-            std::clog << boost::format("GDAL Plugin: pt.x=%f pt.y=%f") % pt.x % pt.y << std::endl;
-            std::clog << boost::format("GDAL Plugin: x=%f y=%f") % x % y << std::endl;
+#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;
 #endif
             GDALRasterBand* band = dataset_.GetRasterBand(band_);
             int hasNoData;
@@ -558,24 +560,24 @@ feature_ptr gdal_featureset::get_feature_at_point(mapnik::coord2d const& pt)
     return feature_ptr();
 }
 
-#ifdef MAPNIK_DEBUG
+#ifdef MAPNIK_LOG
 void gdal_featureset::get_overview_meta(GDALRasterBand* band)
 {
     int band_overviews = band->GetOverviewCount();
     if (band_overviews > 0)
     {
-        std::clog << "GDAL Plugin: "<< band_overviews << " overviews found!" << std::endl;
+        mapnik::log() << "gdal_featureset: " << band_overviews << " overviews found!";
 
         for (int b = 0; b < band_overviews; b++)
         {
             GDALRasterBand * overview = band->GetOverview(b);
-            std::clog << boost::format("GDAL Plugin: Overview=%d Width=%d Height=%d")
-                % b % overview->GetXSize() % overview->GetYSize() << std::endl;
+            mapnik::log() << boost::format("gdal_featureset: Overview=%d Width=%d Height=%d")
+                % b % overview->GetXSize() % overview->GetYSize();
         }
     }
     else
     {
-        std::clog << "GDAL Plugin: No overviews found!" << std::endl;
+        mapnik::log() << "gdal_featureset: No overviews found!";
     }
 
     int bsx,bsy;
@@ -583,8 +585,8 @@ void gdal_featureset::get_overview_meta(GDALRasterBand* band)
     band->GetBlockSize(&bsx, &bsy);
     scale = band->GetScale();
 
-    std::clog << boost::format("GDAL Plugin: Block=%dx%d Scale=%f Type=%s Color=%s") % bsx % bsy % scale
+    mapnik::log() << boost::format("gdal_featureset: Block=%dx%d Scale=%f Type=%s Color=%s") % bsx % bsy % scale
         % GDALGetDataTypeName(band->GetRasterDataType())
-        % GDALGetColorInterpretationName(band->GetColorInterpretation()) << std::endl;
+        % GDALGetColorInterpretationName(band->GetColorInterpretation());
 }
 #endif
diff --git a/plugins/input/gdal/gdal_featureset.hpp b/plugins/input/gdal/gdal_featureset.hpp
index b812da815..e0d8e533d 100644
--- a/plugins/input/gdal/gdal_featureset.hpp
+++ b/plugins/input/gdal/gdal_featureset.hpp
@@ -55,7 +55,7 @@ public:
 private:
     mapnik::feature_ptr get_feature(mapnik::query const& q);
     mapnik::feature_ptr get_feature_at_point(mapnik::coord2d const& p);
-#ifdef MAPNIK_DEBUG
+#ifdef MAPNIK_LOG
     void get_overview_meta(GDALRasterBand * band);
 #endif
     GDALDataset & dataset_;
diff --git a/plugins/input/geos/geos_datasource.cpp b/plugins/input/geos/geos_datasource.cpp
index ddf649ede..58e02cd7a 100644
--- a/plugins/input/geos/geos_datasource.cpp
+++ b/plugins/input/geos/geos_datasource.cpp
@@ -30,8 +30,10 @@
 #include <cstdarg>
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/boolean.hpp>
 #include <mapnik/geom_util.hpp>
+#include <mapnik/timer.hpp>
 
 // boost
 #include <boost/algorithm/string.hpp>
@@ -63,8 +65,10 @@ DATASOURCE_PLUGIN(geos_datasource)
 
 void geos_notice(const char* fmt, ...)
 {
+    // TODO - handle with mapnik::log
+
     va_list ap;
-    fprintf( stdout, "GEOS Plugin: (GEOS NOTICE) ");
+    fprintf( stdout, "Mapnik LOG> geos_datasource: (GEOS NOTICE) ");
 
     va_start (ap, fmt);
     vfprintf( stdout, fmt, ap);
@@ -74,8 +78,10 @@ void geos_notice(const char* fmt, ...)
 
 void geos_error(const char* fmt, ...)
 {
+    // TODO - handle with mapnik::log
+
     va_list ap;
-    fprintf( stdout, "GEOS Plugin: (GEOS ERROR) ");
+    fprintf( stdout, "Mapnik LOG> geos_datasource: (GEOS ERROR) ");
 
     va_start (ap, fmt);
     vfprintf( stdout, fmt, ap);
@@ -94,6 +100,8 @@ 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;
@@ -132,6 +140,10 @@ void geos_datasource::bind() const
 {
     if (is_bound_) return;
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "geos_datasource::bind");
+#endif
+
     // open geos driver
     initGEOS(geos_notice, geos_error);
 
@@ -145,8 +157,12 @@ void geos_datasource::bind() const
     // try to obtain the extent from the geometry itself
     if (! extent_initialized_)
     {
-#ifdef MAPNIK_DEBUG
-        std::clog << "GEOS Plugin: initializing extent from geometry" << std::endl;
+#ifdef MAPNIK_STATS
+        mapnik::progress_timer __stats2__(std::clog, "geos_datasource::bind(initialize_extent)");
+#endif
+
+#ifdef MAPNIK_LOG
+        if (log_enabled_) mapnik::log() << "geos_datasource: Initializing extent from geometry";
 #endif
 
         if (GEOSGeomTypeId(*geometry_) == GEOS_POINT)
@@ -168,10 +184,13 @@ void geos_datasource::bind() const
             geos_feature_ptr envelope (GEOSEnvelope(*geometry_));
             if (*envelope != NULL && GEOSisValid(*envelope))
             {
-#ifdef MAPNIK_DEBUG
-                char* wkt = GEOSGeomToWKT(*envelope);
-                std::clog << "GEOS Plugin: getting coord sequence from: " << wkt << std::endl;
-                GEOSFree(wkt);
+#ifdef MAPNIK_LOG
+                if (log_enabled_)
+                {
+                    char* wkt = GEOSGeomToWKT(*envelope);
+                    mapnik::log() << "geos_datasource: Getting coord sequence from=" << wkt;
+                    GEOSFree(wkt);
+                }
 #endif
 
                 const GEOSGeometry* exterior = GEOSGetExteriorRing(*envelope);
@@ -180,8 +199,8 @@ void geos_datasource::bind() const
                     const GEOSCoordSequence* cs = GEOSGeom_getCoordSeq(exterior);
                     if (cs != NULL)
                     {
-#ifdef MAPNIK_DEBUG
-                        std::clog << "GEOS Plugin: iterating boundary points" << std::endl;
+#ifdef MAPNIK_LOG
+                        if (log_enabled_) mapnik::log() << "geos_datasource: Iterating boundary points";
 #endif
 
                         double x, y;
@@ -242,6 +261,10 @@ boost::optional<mapnik::datasource::geometry_t> geos_datasource::get_geometry_ty
     if (! is_bound_) bind();
     boost::optional<mapnik::datasource::geometry_t> result;
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "geos_datasource::get_geometry_type");
+#endif
+
     // get geometry type
     const int type = GEOSGeomTypeId(*geometry_);
     switch (type)
@@ -280,6 +303,10 @@ featureset_ptr geos_datasource::features(query const& q) const
 {
     if (! is_bound_) bind();
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "geos_datasource::features");
+#endif
+
     const mapnik::box2d<double> extent = q.get_bbox();
 
     std::ostringstream s;
@@ -291,8 +318,8 @@ featureset_ptr geos_datasource::features(query const& q) const
       << extent.minx() << " " << extent.miny()
       << "))";
 
-#ifdef MAPNIK_DEBUG
-    std::clog << "GEOS Plugin: using extent: " << s.str() << std::endl;
+#ifdef MAPNIK_LOG
+    if (log_enabled_) mapnik::log() << "geos_datasource: Using extent=" << s.str();
 #endif
 
     return boost::make_shared<geos_featureset>(*geometry_,
@@ -307,11 +334,15 @@ featureset_ptr geos_datasource::features_at_point(coord2d const& pt) const
 {
     if (! is_bound_) bind();
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "geos_datasource::features_at_point");
+#endif
+
     std::ostringstream s;
     s << "POINT(" << pt.x << " " << pt.y << ")";
 
-#ifdef MAPNIK_DEBUG
-    std::clog << "GEOS Plugin: using point: " << s.str() << std::endl;
+#ifdef MAPNIK_LOG
+    if (log_enabled_) mapnik::log() << "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 237ee21b0..5d9ad33dc 100644
--- a/plugins/input/geos/geos_featureset.cpp
+++ b/plugins/input/geos/geos_featureset.cpp
@@ -26,6 +26,7 @@
 
 // mapnik
 #include <mapnik/global.hpp>
+#include <mapnik/debug.hpp>
 #include <mapnik/datasource.hpp>
 #include <mapnik/box2d.hpp>
 #include <mapnik/geometry.hpp>
@@ -104,8 +105,8 @@ feature_ptr geos_featureset::next()
                     break;
 
                 default:
-#ifdef MAPNIK_DEBUG
-                    std::clog << "GEOS Plugin: unknown extent geometry_type=" << type << std::endl;
+#ifdef MAPNIK_LOG
+                    mapnik::log() << "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 00f604789..034718c6b 100644
--- a/plugins/input/kismet/kismet_datasource.cpp
+++ b/plugins/input/kismet/kismet_datasource.cpp
@@ -34,6 +34,7 @@
 
 // mapnik
 #include <mapnik/boolean.hpp>
+#include <mapnik/debug.hpp>
 
 // boost
 #include <boost/algorithm/string.hpp>
@@ -79,6 +80,8 @@ 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)
     {
@@ -156,7 +159,9 @@ featureset_ptr kismet_datasource::features(query const& q) const
 {
     if (! is_bound_) bind();
 
-    // std::clog << "kismet_datasource::features()" << endl;
+#ifdef MAPNIK_LOG
+    // mapnik::log() << "kismet_datasource::features()";
+#endif
 
     // TODO: use box2d to filter bbox before adding to featureset_ptr
     // mapnik::box2d<double> const& e = q.get_bbox();
@@ -174,15 +179,17 @@ featureset_ptr kismet_datasource::features_at_point(coord2d const& pt) const
 {
     if (! is_bound_) bind();
 
-    // std::clog << "kismet_datasource::features_at_point()" << endl;
+#ifdef MAPNIK_LOG
+    // mapnik::log() << "kismet_datasource::features_at_point()";
+#endif
 
     return featureset_ptr();
 }
 
 void kismet_datasource::run(const std::string& ip_host, const unsigned int port)
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "Kismet Plugin: enter run" << std::endl;
+#ifdef MAPNIK_LOG
+    if (log_enabled_) mapnik::log() << "kismet_datasource: Enter run";
 #endif
 
     int sockfd, n;
@@ -219,7 +226,7 @@ void kismet_datasource::run(const std::string& ip_host, const unsigned int port)
 
     if (connect(sockfd, (struct sockaddr*) &sock_addr, sizeof(sock_addr)))
     {
-        std::cerr << "KISMET Plugin: Error while connecting" << std::endl;
+        std::cerr << "Kismet Plugin: Error while connecting" << std::endl;
         return;
     }
 
@@ -227,7 +234,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;
+        std::cerr << "Kismet Plugin: Error sending command to " << ip_host << std::endl;
 
         close(sockfd);
         return;
@@ -248,8 +255,8 @@ void kismet_datasource::run(const std::string& ip_host, const unsigned int port)
         buffer[n] = '\0';
         std::string bufferObj(buffer); // TCP data send from kismet_server as STL string
 
-#ifdef MAPNIK_DEBUG
-        std::clog << "Kismet Plugin: buffer_obj=" << bufferObj << "[END]" << std::endl;
+#ifdef MAPNIK_LOG
+        if (log_enabled_) mapnik::log() << "kismet_datasource: buffer_obj=" << bufferObj;
 #endif
 
         std::string::size_type found = 0;
@@ -262,8 +269,8 @@ void kismet_datasource::run(const std::string& ip_host, const unsigned int port)
             {
                 kismet_line.assign(bufferObj, search_start, found - search_start);
 
-#ifdef MAPNIK_DEBUG
-                std::clog << "Kismet Plugin: line=" << kismet_line << " [ENDL]" << std::endl;
+#ifdef MAPNIK_LOG
+                if (log_enabled_) mapnik::log() << "kismet_datasource: line=" << kismet_line;
 #endif
 
                 int param_number = 5; // the number of parameters to parse
@@ -277,9 +284,12 @@ void kismet_datasource::run(const std::string& ip_host, const unsigned int port)
                             &bestlat,
                             &bestlon) == param_number)
                 {
-#ifdef MAPNIK_DEBUG
-                    std::clog << "Kismet Plugin: ssid=" << ssid << ", bssid=" << bssid
-                              << ", crypt=" << crypt << ", bestlat=" << bestlat << ", bestlon=" << bestlon << std::endl;
+#ifdef MAPNIK_LOG
+                    if (log_enabled_)
+                    {
+                        mapnik::log() << "kismet_datasource: ssid=" << ssid << ", bssid=" << bssid
+                                      << ", crypt=" << crypt << ", bestlat=" << bestlat << ", bestlon=" << bestlon;
+                    }
 #endif
 
                     kismet_network_data knd(ssid, bssid, bestlat, bestlon, crypt);
@@ -312,8 +322,8 @@ void kismet_datasource::run(const std::string& ip_host, const unsigned int port)
 
     close(sockfd);
 
-#ifdef MAPNIK_DEBUG
-    std::clog << "Kismet Plugin: exit run" << std::endl;
+#ifdef MAPNIK_LOG
+    if (log_enabled_) mapnik::log() << "kismet_datasource: Exit run";
 #endif
 }
 
diff --git a/plugins/input/occi/occi_datasource.cpp b/plugins/input/occi/occi_datasource.cpp
index 16fc1b780..119f9d8a8 100644
--- a/plugins/input/occi/occi_datasource.cpp
+++ b/plugins/input/occi/occi_datasource.cpp
@@ -25,8 +25,10 @@
 #include "occi_featureset.hpp"
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/boolean.hpp>
 #include <mapnik/sql_utils.hpp>
+#include <mapnik/timer.hpp>
 
 // boost
 #include <boost/algorithm/string.hpp>
@@ -68,18 +70,21 @@ const std::string occi_datasource::METADATA_TABLE = "USER_SDO_GEOM_METADATA";
 DATASOURCE_PLUGIN(occi_datasource)
 
 occi_datasource::occi_datasource(parameters const& params, bool bind)
-: datasource (params),
-    type_(datasource::Vector),
-    fields_(*params_.get<std::string>("fields", "*")),
-    geometry_field_(*params_.get<std::string>("geometry_field", "")),
-    srid_initialized_(false),
-    extent_initialized_(false),
-    desc_(*params_.get<std::string>("type"), *params_.get<std::string>("encoding", "utf-8")),
-    row_limit_(*params_.get<int>("row_limit", 0)),
-    row_prefetch_(*params_.get<int>("row_prefetch", 100)),
-    pool_(0),
-    conn_(0)
+    : datasource (params),
+      type_(datasource::Vector),
+      fields_(*params_.get<std::string>("fields", "*")),
+      geometry_field_(*params_.get<std::string>("geometry_field", "")),
+      srid_initialized_(false),
+      extent_initialized_(false),
+      desc_(*params_.get<std::string>("type"), *params_.get<std::string>("encoding", "utf-8")),
+      use_wkb_(*params_.get<mapnik::boolean>("use_wkb", false)),
+      row_limit_(*params_.get<int>("row_limit", 0)),
+      row_prefetch_(*params_.get<int>("row_prefetch", 100)),
+      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");
@@ -140,6 +145,10 @@ void occi_datasource::bind() const
 {
     if (is_bound_) return;
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "occi_datasource::bind");
+#endif
+
     // connect to environment
     if (use_connection_pool_)
     {
@@ -184,6 +193,10 @@ void occi_datasource::bind() const
     // get SRID and/or GEOMETRY_FIELD from metadata table only if we need to
     if (! srid_initialized_ || geometry_field_ == "")
     {
+#ifdef MAPNIK_STATS
+        mapnik::progress_timer __stats__(std::clog, "occi_datasource::get_srid_and_geometry_field");
+#endif
+
         std::ostringstream s;
         s << "SELECT srid, column_name FROM " << METADATA_TABLE << " WHERE";
         s << " LOWER(table_name) = LOWER('" << table_name_ << "')";
@@ -193,8 +206,8 @@ void occi_datasource::bind() const
             s << " AND LOWER(column_name) = LOWER('" << geometry_field_ << "')";
         }
 
-#ifdef MAPNIK_DEBUG
-        std::clog << "OCCI Plugin: " << s.str() << std::endl;
+#ifdef MAPNIK_LOG
+        if (log_enabled_) mapnik::log() << "occi_datasource: " << s.str();
 #endif
 
         try
@@ -226,11 +239,15 @@ void occi_datasource::bind() const
 
     // get columns description
     {
+#ifdef MAPNIK_STATS
+        mapnik::progress_timer __stats__(std::clog, "occi_datasource::get_column_description");
+#endif
+
         std::ostringstream s;
         s << "SELECT " << fields_ << " FROM (" << table_name_ << ") WHERE rownum < 1";
 
-#ifdef MAPNIK_DEBUG
-        std::clog << "OCCI Plugin: " << s.str() << std::endl;
+#ifdef MAPNIK_LOG
+        if (log_enabled_) mapnik::log() << "occi_datasource: " << s.str();
 #endif
 
         try
@@ -321,16 +338,22 @@ void occi_datasource::bind() const
                     case oracle::occi::OCCI_SQLT_CLOB:
                     case oracle::occi::OCCI_SQLT_BLOB:
                     case oracle::occi::OCCI_SQLT_RSET:
-#ifdef MAPNIK_DEBUG
-                        std::clog << "OCCI Plugin: unsupported datatype "
-                                  << occi_enums::resolve_datatype(type_oid)
-                                  << " (type_oid=" << type_oid << ")" << std::endl;
+#ifdef MAPNIK_LOG
+                        if (log_enabled_)
+                        {
+                            mapnik::log() << "occi_datasource: Unsupported datatype "
+                                          << occi_enums::resolve_datatype(type_oid)
+                                          << " (type_oid=" << type_oid << ")";
+                        }
 #endif
                         break;
                     default:
-#ifdef MAPNIK_DEBUG
-                        std::clog << "OCCI Plugin: unknown datatype "
-                                  << "(type_oid=" << type_oid << ")" << std::endl;
+#ifdef MAPNIK_LOG
+                        if (log_enabled_)
+                        {
+                            mapnik::log() << "occi_datasource: Unknown datatype "
+                                          << "(type_oid=" << type_oid << ")";
+                        }
 #endif
                         break;
                     }
@@ -368,13 +391,17 @@ box2d<double> occi_datasource::envelope() const
 
     if (estimate_extent && *estimate_extent)
     {
+#ifdef MAPNIK_STATS
+        mapnik::progress_timer __stats__(std::clog, "occi_datasource::envelope(estimate_extent)");
+#endif
+
         std::ostringstream s;
         s << "SELECT MIN(c.x), MIN(c.y), MAX(c.x), MAX(c.y) FROM ";
         s << " (SELECT SDO_AGGR_MBR(" << geometry_field_ << ") shape FROM " << table_ << ") a, ";
         s << " TABLE(SDO_UTIL.GETVERTICES(a.shape)) c";
 
-#ifdef MAPNIK_DEBUG
-        std::clog << "OCCI Plugin: " << s.str() << std::endl;
+#ifdef MAPNIK_LOG
+        if (log_enabled_) mapnik::log() << "occi_datasource: " << s.str();
 #endif
 
         try
@@ -397,7 +424,7 @@ box2d<double> occi_datasource::envelope() const
                 }
                 catch (bad_lexical_cast& ex)
                 {
-                    std::clog << "OCCI Plugin: " << ex.what() << std::endl;
+                    std::cerr << "OCCI Plugin: " << ex.what() << std::endl;
                 }
             }
         }
@@ -408,6 +435,10 @@ box2d<double> occi_datasource::envelope() const
     }
     else if (use_spatial_index_)
     {
+#ifdef MAPNIK_STATS
+        mapnik::progress_timer __stats__(std::clog, "occi_datasource::envelope(use_spatial_index)");
+#endif
+
         std::ostringstream s;
         s << "SELECT dim.sdo_lb, dim.sdo_ub FROM ";
         s << METADATA_TABLE << " m, TABLE(m.diminfo) dim ";
@@ -417,8 +448,8 @@ box2d<double> occi_datasource::envelope() const
         s << METADATA_TABLE << " m, TABLE(m.diminfo) dim ";
         s << " WHERE LOWER(m.table_name) = LOWER('" << table_name_ << "') AND dim.sdo_dimname = 'Y'";
 
-#ifdef MAPNIK_DEBUG
-        std::clog << "OCCI Plugin: " << s.str() << std::endl;
+#ifdef MAPNIK_LOG
+        if (log_enabled_) mapnik::log() << "occi_datasource: " << s.str();
 #endif
 
         try
@@ -439,7 +470,7 @@ box2d<double> occi_datasource::envelope() const
                     }
                     catch (bad_lexical_cast& ex)
                     {
-                        std::clog << "OCCI Plugin: " << ex.what() << std::endl;
+                        std::cerr << "OCCI Plugin: " << ex.what() << std::endl;
                     }
                 }
 
@@ -452,7 +483,7 @@ box2d<double> occi_datasource::envelope() const
                     }
                     catch (bad_lexical_cast& ex)
                     {
-                        std::clog << "OCCI Plugin: " << ex.what() << std::endl;
+                        std::cerr << "OCCI Plugin: " << ex.what() << std::endl;
                     }
                 }
 
@@ -493,15 +524,27 @@ featureset_ptr occi_datasource::features(query const& q) const
 {
     if (! is_bound_) bind();
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "occi_datasource::features");
+#endif
+
     box2d<double> const& box = q.get_bbox();
 
     std::ostringstream s;
-    s << "SELECT " << geometry_field_;
+    s << "SELECT ";
+    if (use_wkb_)
+    {
+        s << "SDO_UTIL.TO_WKBGEOMETRY(" << geometry_field_ << ")";
+    }
+    else
+    {
+        s << geometry_field_;
+    }
     std::set<std::string> const& props = q.property_names();
     std::set<std::string>::const_iterator pos = props.begin();
     std::set<std::string>::const_iterator end = props.end();
     mapnik::context_ptr ctx = boost::make_shared<mapnik::context_type>();
-    for ( ;pos != end;++pos)
+    for (; pos != end; ++pos)
     {
         s << ", " << *pos;
         ctx->push(*pos);
@@ -532,8 +575,8 @@ featureset_ptr occi_datasource::features(query const& q) const
         }
         else
         {
-#ifdef MAPNIK_DEBUG
-            std::clog << "OCCI Plugin: cannot determine where to add the spatial filter declaration" << std::endl;
+#ifdef MAPNIK_LOG
+            if (log_enabled_) mapnik::log() << "occi_datasource: cannot determine where to add the spatial filter declaration";
 #endif
         }
     }
@@ -552,16 +595,16 @@ featureset_ptr occi_datasource::features(query const& q) const
         }
         else
         {
-#ifdef MAPNIK_DEBUG
-            std::clog << "OCCI Plugin: cannot determine where to add the row limit declaration" << std::endl;
+#ifdef MAPNIK_LOG
+            if (log_enabled_) mapnik::log() << "occi_datasource: Cannot determine where to add the row limit declaration";
 #endif
         }
     }
 
     s << query;
 
-#ifdef MAPNIK_DEBUG
-    std::clog << "OCCI Plugin: " << s.str() << std::endl;
+#ifdef MAPNIK_LOG
+    if (log_enabled_) mapnik::log() << "occi_datasource: " << s.str();
 #endif
 
     return boost::make_shared<occi_featureset>(pool_,
@@ -570,6 +613,7 @@ featureset_ptr occi_datasource::features(query const& q) const
                                                s.str(),
                                                desc_.get_encoding(),
                                                use_connection_pool_,
+                                               use_wkb_,
                                                row_prefetch_);
 }
 
@@ -577,8 +621,20 @@ featureset_ptr occi_datasource::features_at_point(coord2d const& pt) const
 {
     if (! is_bound_) bind();
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "occi_datasource::features_at_point");
+#endif
+
     std::ostringstream s;
-    s << "SELECT " << geometry_field_;
+    s << "SELECT ";
+    if (use_wkb_)
+    {
+        s << "SDO_UTIL.TO_WKBGEOMETRY(" << geometry_field_ << ")";
+    }
+    else
+    {
+        s << geometry_field_;
+    }
     std::vector<attribute_descriptor>::const_iterator itr = desc_.get_descriptors().begin();
     std::vector<attribute_descriptor>::const_iterator end = desc_.get_descriptors().end();
     mapnik::context_ptr ctx = boost::make_shared<mapnik::context_type>();
@@ -613,8 +669,8 @@ featureset_ptr occi_datasource::features_at_point(coord2d const& pt) const
         }
         else
         {
-#ifdef MAPNIK_DEBUG
-            std::clog << "OCCI Plugin: cannot determine where to add the spatial filter declaration" << std::endl;
+#ifdef MAPNIK_LOG
+            if (log_enabled_) mapnik::log() << "occi_datasource: Cannot determine where to add the spatial filter declaration";
 #endif
         }
     }
@@ -633,16 +689,16 @@ featureset_ptr occi_datasource::features_at_point(coord2d const& pt) const
         }
         else
         {
-#ifdef MAPNIK_DEBUG
-            std::clog << "OCCI Plugin: cannot determine where to add the row limit declaration" << std::endl;
+#ifdef MAPNIK_LOG
+            if (log_enabled_) mapnik::log() << "occi_datasource: Cannot determine where to add the row limit declaration";
 #endif
         }
     }
 
     s << query;
 
-#ifdef MAPNIK_DEBUG
-    std::clog << "OCCI Plugin: " << s.str() << std::endl;
+#ifdef MAPNIK_LOG
+    if (log_enabled_) mapnik::log() << "occi_datasource: " << s.str();
 #endif
 
     return boost::make_shared<occi_featureset>(pool_,
@@ -651,5 +707,6 @@ featureset_ptr occi_datasource::features_at_point(coord2d const& pt) const
                                                s.str(),
                                                desc_.get_encoding(),
                                                use_connection_pool_,
+                                               use_wkb_,
                                                row_prefetch_);
 }
diff --git a/plugins/input/occi/occi_datasource.hpp b/plugins/input/occi/occi_datasource.hpp
index ed235305c..e9507d8b3 100644
--- a/plugins/input/occi/occi_datasource.hpp
+++ b/plugins/input/occi/occi_datasource.hpp
@@ -50,6 +50,8 @@ public:
     void bind() const;
 
 private:
+    static const std::string METADATA_TABLE;
+
     mapnik::datasource::datasource_t type_;
     mutable std::string table_;
     mutable std::string table_name_;
@@ -60,13 +62,13 @@ private:
     mutable bool extent_initialized_;
     mutable mapnik::box2d<double> extent_;
     mutable mapnik::layer_descriptor desc_;
+    mutable bool use_wkb_;
     int row_limit_;
     int row_prefetch_;
     mutable oracle::occi::StatelessConnectionPool* pool_;
     mutable oracle::occi::Connection* conn_;
     bool use_connection_pool_;
     bool use_spatial_index_;
-    static const std::string METADATA_TABLE;
 };
 
 #endif // OCCI_DATASOURCE_HPP
diff --git a/plugins/input/occi/occi_featureset.cpp b/plugins/input/occi/occi_featureset.cpp
index 3a09200f3..55e4abc6f 100644
--- a/plugins/input/occi/occi_featureset.cpp
+++ b/plugins/input/occi/occi_featureset.cpp
@@ -22,6 +22,7 @@
 
 // mapnik
 #include <mapnik/global.hpp>
+#include <mapnik/debug.hpp>
 #include <mapnik/datasource.hpp>
 #include <mapnik/box2d.hpp>
 #include <mapnik/geometry.hpp>
@@ -61,10 +62,12 @@ occi_featureset::occi_featureset(StatelessConnectionPool* pool,
                                  std::string const& sqlstring,
                                  std::string const& encoding,
                                  bool use_connection_pool,
+                                 bool use_wkb,
                                  unsigned prefetch_rows)
     : tr_(new transcoder(encoding)),
       feature_id_(1),
-      ctx_(ctx)
+      ctx_(ctx),
+      use_wkb_(use_wkb)
 {
     if (use_connection_pool)
     {
@@ -81,7 +84,7 @@ occi_featureset::occi_featureset(StatelessConnectionPool* pool,
     }
     catch (SQLException &ex)
     {
-        std::clog << "OCCI Plugin: error processing " << sqlstring << " : " << ex.getMessage() << std::endl;
+        std::cerr << "OCCI Plugin: error processing " << sqlstring << " : " << ex.getMessage() << std::endl;
     }
 }
 
@@ -96,10 +99,31 @@ feature_ptr occi_featureset::next()
         feature_ptr feature(feature_factory::create(ctx_,feature_id_));
         ++feature_id_;
 
-        boost::scoped_ptr<SDOGeometry> geom(dynamic_cast<SDOGeometry*>(rs_->getObject(1)));
-        if (geom.get())
+        if (use_wkb_)
         {
-            convert_geometry(geom.get(), feature);
+            Blob blob = rs_->getBlob (1);
+            blob.open(oracle::occi::OCCI_LOB_READONLY);
+
+            int size = blob.length();
+            if (buffer_.size() < size)
+            {
+                buffer_.resize(size);
+            }
+
+            oracle::occi::Stream* instream = blob.getStream(1,0);
+            instream->readBuffer(buffer_.data(), size);
+            blob.closeStream(instream);
+            blob.close();
+
+            geometry_utils::from_wkb(feature->paths(), buffer_.data(), size);
+        }
+        else
+        {
+            boost::scoped_ptr<SDOGeometry> geom(dynamic_cast<SDOGeometry*>(rs_->getObject(1)));
+            if (geom.get())
+            {
+                convert_geometry(geom.get(), feature);
+            }
         }
 
         std::vector<MetaData> listOfColumns = rs_->getColumnListMetaData();
@@ -180,18 +204,22 @@ feature_ptr occi_featureset::next()
             case oracle::occi::OCCI_SQLT_CLOB:
             case oracle::occi::OCCI_SQLT_BLOB:
             case oracle::occi::OCCI_SQLT_RSET:
-#ifdef MAPNIK_DEBUG
-                std::clog << "OCCI Plugin: unsupported datatype "
-                          << occi_enums::resolve_datatype(type_oid)
-                          << " (type_oid=" << type_oid << ")" << std::endl;
+                {
+#ifdef MAPNIK_LOG
+                    mapnik::log() << "occi_featureset: Unsupported datatype "
+                                  << occi_enums::resolve_datatype(type_oid)
+                                  << " (type_oid=" << type_oid << ")";
 #endif
-                break;
+                    break;
+                }
             default: // shouldn't get here
-#ifdef MAPNIK_DEBUG
-                std::clog << "OCCI Plugin: unknown datatype "
-                          << "(type_oid=" << type_oid << ")" << std::endl;
+                {
+#ifdef MAPNIK_LOG
+                    mapnik::log() << "occi_featureset: Unknown datatype "
+                                  << "(type_oid=" << type_oid << ")";
 #endif
-                break;
+                    break;
+                }
             }
         }
 
@@ -209,20 +237,6 @@ void occi_featureset::convert_geometry(SDOGeometry* geom, feature_ptr feature)
     int lrsvalue = (gtype - dimensions * 1000) / 100;
     int geomtype = (gtype - dimensions * 1000 - lrsvalue * 100);
 
-#if 0
-    std::clog << "-----------Geometry Object ------------" << std::endl;
-    std::clog << "SDO GTYPE = " << gtype << std::endl;
-    std::clog << "SDO DIMENSIONS = " << dimensions << std::endl;
-    std::clog << "SDO LRS = " << lrsvalue << std::endl;
-    std::clog << "SDO GEOMETRY TYPE = " << geomtype << std::endl;
-
-    Number sdo_srid = geom->getSdo_srid();
-    if (sdo_srid.isNull())
-        std::clog << "SDO SRID = " << "Null" << std::endl;
-    else
-        std::clog << "SDO SRID = " << (int)sdo_srid << std::endl;
-#endif
-
     const std::vector<Number>& elem_info = geom->getSdo_elem_info();
     const std::vector<Number>& ordinates = geom->getSdo_ordinates();
     const int ordinates_size = (int)ordinates.size();
@@ -344,12 +358,14 @@ void occi_featureset::convert_geometry(SDOGeometry* geom, feature_ptr feature)
     break;
     case SDO_GTYPE_UNKNOWN:
     default:
-#ifdef MAPNIK_DEBUG
-        std::clog << "OCCI Plugin: unknown <occi> "
-                  << occi_enums::resolve_gtype(geomtype)
-                  << "(gtype=" << gtype << ")" << std::endl;
+    {
+#ifdef MAPNIK_LOG
+        mapnik::log() << "occi_featureset: Unknown oracle enum "
+                      << occi_enums::resolve_gtype(geomtype)
+                      << "(gtype=" << gtype << ")";
 #endif
-        break;
+    }
+    break;
     }
 }
 
diff --git a/plugins/input/occi/occi_featureset.hpp b/plugins/input/occi/occi_featureset.hpp
index 1ad3be653..47b473278 100644
--- a/plugins/input/occi/occi_featureset.hpp
+++ b/plugins/input/occi/occi_featureset.hpp
@@ -35,6 +35,8 @@
 // oci
 #include "occi_types.hpp"
 
+#include <vector>
+
 class occi_featureset : public mapnik::Featureset
 {
 public:
@@ -44,6 +46,7 @@ public:
                     std::string const& sqlstring,
                     std::string const& encoding,
                     bool use_connection_pool,
+                    bool use_wkb,
                     unsigned prefetch_rows);
     virtual ~occi_featureset();
     mapnik::feature_ptr next();
@@ -70,6 +73,8 @@ private:
     const char* fidcolumn_;
     mutable int feature_id_;
     mapnik::context_ptr ctx_;
+    bool use_wkb_;
+    std::vector<char> buffer_;
 };
 
 #endif // OCCI_FEATURESET_HPP
diff --git a/plugins/input/occi/occi_types.hpp b/plugins/input/occi/occi_types.hpp
index 38201a0c3..30506a2ea 100644
--- a/plugins/input/occi/occi_types.hpp
+++ b/plugins/input/occi/occi_types.hpp
@@ -24,6 +24,7 @@
 #define OCCI_TYPES_HPP
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/utils.hpp>
 
 // occi
@@ -87,8 +88,8 @@ public:
     {
         if (env_ == 0)
         {
-#ifdef MAPNIK_DEBUG
-            std::clog << "OCCI Plugin: occi_environment constructor" << std::endl;
+#ifdef MAPNIK_LOG
+            mapnik::log() << "occi_environment: constructor";
 #endif
 
             const int mode = oracle::occi::Environment::OBJECT
@@ -111,8 +112,8 @@ private:
     {
         if (env_)
         {
-#ifdef MAPNIK_DEBUG
-            std::clog << "OCCI Plugin: occi_environment destructor" << std::endl;
+#ifdef MAPNIK_LOG
+            mapnik::log() << "occi_environment: destructor";
 #endif
 
             oracle::occi::Environment::terminateEnvironment(env_);
diff --git a/plugins/input/ogr/ogr_converter.cpp b/plugins/input/ogr/ogr_converter.cpp
index 9c6bb4f9f..a372e1fce 100644
--- a/plugins/input/ogr/ogr_converter.cpp
+++ b/plugins/input/ogr/ogr_converter.cpp
@@ -22,6 +22,7 @@
 
 // mapnik
 #include <mapnik/global.hpp>
+#include <mapnik/debug.hpp>
 #include <mapnik/box2d.hpp>
 #include <mapnik/geometry.hpp>
 #include <mapnik/feature.hpp>
@@ -68,10 +69,12 @@ void ogr_converter::convert_geometry(OGRGeometry* geom, feature_ptr feature)
     case wkbNone:
     case wkbUnknown:
     default:
-#ifdef MAPNIK_DEBUG
-        std::clog << "OGR Plugin: unknown <ogr> geometry_type="
-                  << wkbFlatten(geom->getGeometryType()) << std::endl;
+        {
+#ifdef MAPNIK_LOG
+            mapnik::log() << "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 1e7122b51..6316646d7 100644
--- a/plugins/input/ogr/ogr_datasource.cpp
+++ b/plugins/input/ogr/ogr_datasource.cpp
@@ -33,8 +33,10 @@
 #include <gdal_version.h>
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/boolean.hpp>
 #include <mapnik/geom_util.hpp>
+#include <mapnik/timer.hpp>
 
 // boost
 #include <boost/algorithm/string.hpp>
@@ -63,6 +65,8 @@ 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)
@@ -108,6 +112,10 @@ void ogr_datasource::bind() const
 {
     if (is_bound_) return;
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "ogr_datasource::bind");
+#endif
+
     // initialize ogr formats
     OGRRegisterAll();
 
@@ -182,6 +190,10 @@ void ogr_datasource::bind() const
     }
     else if (layer_by_sql)
     {
+#ifdef MAPNIK_STATS
+        mapnik::progress_timer __stats_sql__(std::clog, "ogr_datasource::bind(layer_by_sql)");
+#endif
+
         layer_.layer_by_sql(dataset_, *layer_by_sql);
         layer_name_ = layer_.layer_name();
     }
@@ -259,15 +271,23 @@ void ogr_datasource::bind() const
         indexed_ = true;
         index_file.close();
     }
+#ifdef MAPNIK_LOG
 #if 0
     // TODO - enable this warning once the ogrindex tool is a bit more stable/mature
     else
     {
-        std::clog << "### Notice: no ogrindex file found for " << dataset_name_
-                  << ", use the 'ogrindex' program to build an index for faster rendering"
-                  << std::endl;
+        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";
+        }
     }
 #endif
+#endif // MAPNIK_LOG
+
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats2__(std::clog, "ogr_datasource::bind(get_column_description)");
+#endif
 
     // deal with attributes descriptions
     OGRFeatureDefn* def = layer->GetLayerDefn();
@@ -304,16 +324,16 @@ void ogr_datasource::bind() const
             case OFTRealList:
             case OFTStringList:
             case OFTWideStringList: // deprecated !
-#ifdef MAPNIK_DEBUG
-                std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl;
+#ifdef MAPNIK_LOG
+                if (log_enabled_) mapnik::log() << "ogr_datasource: Unhandled type_oid=" << type_oid;
 #endif
                 break;
 
             case OFTDate:
             case OFTTime:
             case OFTDateTime: // unhandled !
-#ifdef MAPNIK_DEBUG
-                std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl;
+#ifdef MAPNIK_LOG
+                if (log_enabled_) mapnik::log() << "ogr_datasource: Unhandled type_oid=" << type_oid;
 #endif
                 desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::Object));
                 break;
@@ -350,7 +370,7 @@ boost::optional<mapnik::datasource::geometry_t> ogr_datasource::get_geometry_typ
 #if GDAL_VERSION_NUM < 1800
         switch (wkbFlatten(layer->GetLayerDefn()->GetGeomType()))
 #else
-            switch (wkbFlatten(layer->GetGeomType()))
+        switch (wkbFlatten(layer->GetGeomType()))
 #endif
             {
             case wkbPoint:
@@ -464,6 +484,10 @@ featureset_ptr ogr_datasource::features(query const& q) const
 {
     if (! is_bound_) bind();
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "ogr_datasource::features");
+#endif
+
     if (dataset_ && layer_.is_valid())
     {
         // First we validate query fields: https://github.com/mapnik/mapnik/issues/792
@@ -511,6 +535,10 @@ featureset_ptr ogr_datasource::features_at_point(coord2d const& pt) const
 {
     if (!is_bound_) bind();
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "ogr_datasource::features_at_point");
+#endif
+
     if (dataset_ && layer_.is_valid())
     {
         std::vector<attribute_descriptor> const& desc_ar = desc_.get_descriptors();
@@ -532,8 +560,7 @@ featureset_ptr ogr_datasource::features_at_point(coord2d const& pt) const
                                                                              *layer,
                                                                              filter,
                                                                              index_name_,
-                                                                             desc_.get_encoding()
-                                      ));
+                                                                             desc_.get_encoding()));
         }
         else
         {
@@ -545,8 +572,7 @@ featureset_ptr ogr_datasource::features_at_point(coord2d const& pt) const
                                                       *dataset_,
                                                       *layer,
                                                       point,
-                                                      desc_.get_encoding()
-                                      ));
+                                                      desc_.get_encoding()));
         }
     }
 
diff --git a/plugins/input/ogr/ogr_featureset.cpp b/plugins/input/ogr/ogr_featureset.cpp
index 37260087b..daea475ef 100644
--- a/plugins/input/ogr/ogr_featureset.cpp
+++ b/plugins/input/ogr/ogr_featureset.cpp
@@ -22,6 +22,7 @@
 
 // mapnik
 #include <mapnik/global.hpp>
+#include <mapnik/debug.hpp>
 #include <mapnik/datasource.hpp>
 #include <mapnik/box2d.hpp>
 #include <mapnik/geometry.hpp>
@@ -102,11 +103,10 @@ feature_ptr ogr_featureset::next()
         {
             ogr_converter::convert_geometry(geom, feature);
         }
-#ifdef MAPNIK_DEBUG
+#ifdef MAPNIK_LOG
         else
         {
-            std::clog << "OGR Plugin: feature with null geometry: "
-                      << (*feat)->GetFID() << std::endl;
+            mapnik::log() << "ogr_featureset: Feature with null geometry=" << (*feat)->GetFID();
         }
 #endif
         ++count_;
@@ -145,16 +145,16 @@ feature_ptr ogr_featureset::next()
             case OFTStringList:
             case OFTWideStringList: // deprecated !
             {
-#ifdef MAPNIK_DEBUG
-                std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl;
+#ifdef MAPNIK_LOG
+                mapnik::log() << "ogr_featureset: Unhandled type_oid=" << type_oid;
 #endif
                 break;
             }
 
             case OFTBinary:
             {
-#ifdef MAPNIK_DEBUG
-                std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl;
+#ifdef MAPNIK_LOG
+                mapnik::log() << "ogr_featureset: Unhandled type_oid=" << type_oid;
 #endif
                 //feature->put(name,feat->GetFieldAsBinary (i, size));
                 break;
@@ -164,16 +164,16 @@ feature_ptr ogr_featureset::next()
             case OFTTime:
             case OFTDateTime:       // unhandled !
             {
-#ifdef MAPNIK_DEBUG
-                std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl;
+#ifdef MAPNIK_LOG
+                mapnik::log() << "ogr_featureset: Unhandled type_oid=" << type_oid;
 #endif
                 break;
             }
 
             default: // unknown
             {
-#ifdef MAPNIK_DEBUG
-                std::clog << "OGR Plugin: unknown type_oid=" << type_oid << std::endl;
+#ifdef MAPNIK_LOG
+                mapnik::log() << "ogr_featureset: Unknown type_oid=" << type_oid;
 #endif
                 break;
             }
@@ -182,8 +182,9 @@ feature_ptr ogr_featureset::next()
         return feature;
     }
 
-#ifdef MAPNIK_DEBUG
-    std::clog << "OGR Plugin: " << count_ << " features" << std::endl;
+#ifdef MAPNIK_LOG
+    mapnik::log() << "ogr_featureset: " << count_ << " features";
 #endif
+
     return feature_ptr();
 }
diff --git a/plugins/input/ogr/ogr_index_featureset.cpp b/plugins/input/ogr/ogr_index_featureset.cpp
index 85355c072..22435b699 100644
--- a/plugins/input/ogr/ogr_index_featureset.cpp
+++ b/plugins/input/ogr/ogr_index_featureset.cpp
@@ -23,6 +23,7 @@
 
 // mapnik
 #include <mapnik/global.hpp>
+#include <mapnik/debug.hpp>
 #include <mapnik/datasource.hpp>
 #include <mapnik/box2d.hpp>
 #include <mapnik/geometry.hpp>
@@ -76,8 +77,8 @@ ogr_index_featureset<filterT>::ogr_index_featureset(mapnik::context_ptr const &
 
     std::sort(ids_.begin(),ids_.end());
 
-#ifdef MAPNIK_DEBUG
-    std::clog << "OGR Plugin: query size=" << ids_.size() << std::endl;
+#ifdef MAPNIK_LOG
+    mapnik::log() << "ogr_index_featureset: Query size=" << ids_.size();
 #endif
 
     itr_ = ids_.begin();
@@ -110,10 +111,10 @@ feature_ptr ogr_index_featureset<filterT>::next()
             {
                 ogr_converter::convert_geometry (geom, feature);
             }
-#ifdef MAPNIK_DEBUG
+#ifdef MAPNIK_LOG
             else
             {
-                std::clog << "### Warning: feature with null geometry: " << (*feat)->GetFID() << "\n";
+                mapnik::log() << "ogr_index_featureset: Feature with null geometry=" << (*feat)->GetFID();
             }
 #endif
 
@@ -151,16 +152,16 @@ feature_ptr ogr_index_featureset<filterT>::next()
                 case OFTStringList:
                 case OFTWideStringList: // deprecated !
                 {
-#ifdef MAPNIK_DEBUG
-                    std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl;
+#ifdef MAPNIK_LOG
+                    mapnik::log() << "ogr_index_featureset: Unhandled type_oid=" << type_oid;
 #endif
                     break;
                 }
 
                 case OFTBinary:
                 {
-#ifdef MAPNIK_DEBUG
-                    std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl;
+#ifdef MAPNIK_LOG
+                    mapnik::log() << "ogr_index_featureset: Unhandled type_oid=" << type_oid;
 #endif
                     //feature->put(name,feat->GetFieldAsBinary (i, size));
                     break;
@@ -170,8 +171,8 @@ feature_ptr ogr_index_featureset<filterT>::next()
                 case OFTTime:
                 case OFTDateTime:       // unhandled !
                 {
-#ifdef MAPNIK_DEBUG
-                    std::clog << "OGR Plugin: unhandled type_oid=" << type_oid << std::endl;
+#ifdef MAPNIK_LOG
+                    mapnik::log() << "ogr_index_featureset: Unhandled type_oid=" << type_oid;
 #endif
                     break;
                 }
@@ -186,4 +187,3 @@ feature_ptr ogr_index_featureset<filterT>::next()
 
 template class ogr_index_featureset<mapnik::filter_in_box>;
 template class ogr_index_featureset<mapnik::filter_at_point>;
-
diff --git a/plugins/input/ogr/ogr_layer_ptr.hpp b/plugins/input/ogr/ogr_layer_ptr.hpp
index b3353518c..7c9ea6151 100644
--- a/plugins/input/ogr/ogr_layer_ptr.hpp
+++ b/plugins/input/ogr/ogr_layer_ptr.hpp
@@ -23,6 +23,9 @@
 #ifndef OGR_LAYER_PTR_HPP
 #define OGR_LAYER_PTR_HPP
 
+// mapnik
+#include <mapnik/debug.hpp>
+
 // stl
 #include <iostream>
 #include <fstream>
@@ -75,12 +78,12 @@ public:
             layer_ = ogr_layer;
             is_valid_ = true;
 
-#ifdef MAPNIK_DEBUG
-            std::clog << "OGR Plugin: layer_from_name layer is " << layer_name_ << std::endl;
+#ifdef MAPNIK_LOG
+            mapnik::log() << "ogr_layer_ptr: layer_from_name layer=" << layer_name_;
 #endif
         }
 
-#ifdef MAPNIK_DEBUG
+#ifdef MAPNIK_LOG
         debug_print_last_error();
 #endif
     }
@@ -102,13 +105,13 @@ public:
                 layer_name_ = def->GetName();
                 is_valid_ = true;
 
-#ifdef MAPNIK_DEBUG
-                std::clog << "OGR Plugin: layer_from_index layer is " << layer_name_ << std::endl;
+#ifdef MAPNIK_LOG
+                mapnik::log() << "ogr_layer_ptr: layer_from_index layer=" << layer_name_;
 #endif
             }
         }
 
-#ifdef MAPNIK_DEBUG
+#ifdef MAPNIK_LOG
         debug_print_last_error();
 #endif
     }
@@ -138,13 +141,13 @@ public:
                 layer_name_ = def->GetName();
                 is_valid_ = true;
 
-#ifdef MAPNIK_DEBUG
-                std::clog << "OGR Plugin: layer_from_sql layer is " << layer_name_ << std::endl;
+#ifdef MAPNIK_LOG
+                mapnik::log() << "ogr_layer_ptr: layer_from_sql layer=" << layer_name_;
 #endif
             }
         }
 
-#ifdef MAPNIK_DEBUG
+#ifdef MAPNIK_LOG
         debug_print_last_error();
 #endif
     }
@@ -166,7 +169,7 @@ public:
 
 private:
 
-#ifdef MAPNIK_DEBUG
+#ifdef MAPNIK_LOG
     void debug_print_last_error()
     {
         if (! is_valid_)
@@ -174,11 +177,11 @@ private:
             const std::string err = CPLGetLastErrorMsg();
             if (err.size() == 0)
             {
-                std::clog << "OGR Plugin: error getting layer" << std::endl;
+                mapnik::log() << "ogr_layer_ptr: Error getting layer";
             }
             else
             {
-                std::clog << "OGR Plugin: " << err << std::endl;
+                mapnik::log() << "ogr_layer_ptr: " << err;
             }
         }
     }
diff --git a/plugins/input/osm/dataset_deliverer.cpp b/plugins/input/osm/dataset_deliverer.cpp
index 694bcd8a7..ab1acb900 100644
--- a/plugins/input/osm/dataset_deliverer.cpp
+++ b/plugins/input/osm/dataset_deliverer.cpp
@@ -20,11 +20,18 @@
  *
  *****************************************************************************/
 
+// mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/datasource.hpp>
+
+// boost
 #include <boost/filesystem/operations.hpp>
+
+// std
+#include <sstream>
+
 #include "dataset_deliverer.h"
 #include "basiccurl.h"
-#include <sstream>
 
 osm_dataset * dataset_deliverer::dataset = NULL;
 std::string dataset_deliverer::last_bbox = "";
@@ -76,8 +83,8 @@ osm_dataset* dataset_deliverer::load_from_url(const string& url, const string& b
     }
     else if (bbox != last_bbox)
     {
-#ifdef MAPNIK_DEBUG
-        std::cerr << "Osm Plugin: BBOXES ARE DIFFERENT: " << last_bbox << "," << bbox << std::endl;
+#ifdef MAPNIK_LOG
+        mapnik::log() << "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 87207b469..26a998938 100644
--- a/plugins/input/osm/osm.cpp
+++ b/plugins/input/osm/osm.cpp
@@ -24,6 +24,8 @@
 #include "osmparser.h"
 #include "basiccurl.h"
 
+#include <mapnik/debug.hpp>
+
 #include <libxml/parser.h>
 #include <iostream>
 #include <fstream>
@@ -47,8 +49,8 @@ bool osm_dataset::load_from_url(const std::string& url,
 {
     if (parser == "libxml2")
     {
-#ifdef MAPNIK_DEBUG
-        std::clog << "Osm Plugin: osm_dataset::load_from_url url=" << url << " bbox=" << bbox << std::endl;
+#ifdef MAPNIK_LOG
+        mapnik::log() << "osm_dataset: load_from_url url=" << url << ",bbox=" << bbox;
 #endif
 
         std::ostringstream str;
@@ -57,8 +59,8 @@ bool osm_dataset::load_from_url(const std::string& url,
 
         str << url << "?bbox=" << bbox;
 
-#ifdef MAPNIK_DEBUG
-        std::clog << "Osm Plugin: FULL URL " << str.str() << std::endl;
+#ifdef MAPNIK_LOG
+        mapnik::log() << "osm_dataset: Full url=" << str.str();
 #endif
 
         CURL_LOAD_DATA* resp = grab_http_response(str.str().c_str());
@@ -69,8 +71,8 @@ bool osm_dataset::load_from_url(const std::string& url,
             memcpy(blx, resp->data, resp->nbytes);
             blx[resp->nbytes] = '\0';
 
-#ifdef MAPNIK_DEBUG
-            std::clog << "Osm Plugin: CURL RESPONSE: " << blx << std::endl;
+#ifdef MAPNIK_LOG
+            mapnik::log() << "osm_dataset: CURL Response=" << blx;
 #endif
 
             delete[] blx;
@@ -88,36 +90,32 @@ osm_dataset::~osm_dataset()
 
 void osm_dataset::clear()
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "Osm Plugin: osm_dataset::clear()" << std::endl;
-    std::clog << "Osm Plugin: deleting ways" << std::endl;
+#ifdef MAPNIK_LOG
+    mapnik::log() << "osm_dataset: Clear";
 #endif
 
+#ifdef MAPNIK_LOG
+    mapnik::log() << "osm_dataset: -- Deleting ways";
+#endif
     for (unsigned int count = 0; count < ways.size(); ++count)
     {
         delete ways[count];
         ways[count] = NULL;
     }
+    ways.clear();
 
-#ifdef MAPNIK_DEBUG
-    std::clog << "Osm Plugin: deleting nodes" << std::endl;
+#ifdef MAPNIK_LOG
+    mapnik::log() << "osm_dataset: -- Deleting nodes";
 #endif
-
     for (unsigned int count = 0; count < nodes.size(); ++count)
     {
         delete nodes[count];
         nodes[count] = NULL;
     }
-
-#ifdef MAPNIK_DEBUG
-    std::clog << "Osm Plugin: clearing ways/nodes" << std::endl;
-#endif
-
-    ways.clear();
     nodes.clear();
 
-#ifdef MAPNIK_DEBUG
-    std::clog << "Osm Plugin: done" << std::endl;
+#ifdef MAPNIK_LOG
+    mapnik::log() << "osm_dataset: Clear done";
 #endif
 }
 
diff --git a/plugins/input/osm/osm_datasource.cpp b/plugins/input/osm/osm_datasource.cpp
index 90cebc0fe..1884ff45b 100644
--- a/plugins/input/osm/osm_datasource.cpp
+++ b/plugins/input/osm/osm_datasource.cpp
@@ -28,8 +28,10 @@
 #include <set>
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/geom_util.hpp>
 #include <mapnik/query.hpp>
+#include <mapnik/boolean.hpp>
 
 // boost
 #include <boost/make_shared.hpp>
@@ -51,11 +53,13 @@ using mapnik::attribute_descriptor;
 DATASOURCE_PLUGIN(osm_datasource)
 
 osm_datasource::osm_datasource(const parameters& params, bool bind)
-: datasource (params),
-    extent_(),
-    type_(datasource::Vector),
-    desc_(*params_.get<std::string>("type"), *params_.get<std::string>("encoding", "utf-8"))
+    : datasource (params),
+      extent_(),
+      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();
@@ -77,9 +81,10 @@ void osm_datasource::bind() const
     if (url != "" && bbox != "")
     {
         // if we supplied a url and a bounding box, load from the url
-#ifdef MAPNIK_DEBUG
-        std::clog << "Osm Plugin: loading_from_url: url=" << url << " bbox=" << bbox << std::endl;
+#ifdef MAPNIK_LOG
+        if (log_enabled_) mapnik::log() << "osm_datasource: loading_from_url url=" << url << ",bbox=" << bbox;
 #endif
+
         if ((osm_data_ = dataset_deliverer::load_from_url(url, bbox, parser)) == NULL)
         {
             throw datasource_exception("Error loading from URL");
@@ -94,7 +99,9 @@ void osm_datasource::bind() const
             s << "OSM Plugin: Error loading from file '" << osm_filename << "'";
             throw datasource_exception(s.str());
         }
-    } else {
+    }
+    else
+    {
         throw datasource_exception("OSM Plugin: Neither 'file' nor 'url' and 'bbox' specified");
     }
 
diff --git a/plugins/input/osm/osm_datasource.hpp b/plugins/input/osm/osm_datasource.hpp
index 42bdb6889..dc0c8fe51 100644
--- a/plugins/input/osm/osm_datasource.hpp
+++ b/plugins/input/osm/osm_datasource.hpp
@@ -43,21 +43,19 @@ public:
     osm_datasource(const parameters& params, bool bind = true);
     virtual ~osm_datasource();
     mapnik::datasource::datasource_t type() const;
+    static std::string name();
     featureset_ptr features(const query& q) const;
     featureset_ptr features_at_point(coord2d const& pt) const;
     box2d<double> envelope() const;
     boost::optional<mapnik::datasource::geometry_t> get_geometry_type() const;
     layer_descriptor get_descriptor() const;
-    static std::string name();
     void bind() const;
+
 private:
     mutable box2d<double> extent_;
     mutable osm_dataset* osm_data_;
     mapnik::datasource::datasource_t type_;
     mutable layer_descriptor desc_;
-    // no copying
-    osm_datasource(const osm_datasource&);
-    osm_datasource& operator=(const osm_datasource&);
 };
 
 #endif // OSM_DATASOURCE_HPP
diff --git a/plugins/input/postgis/connection.hpp b/plugins/input/postgis/connection.hpp
index a0325fce3..081d03db6 100644
--- a/plugins/input/postgis/connection.hpp
+++ b/plugins/input/postgis/connection.hpp
@@ -20,10 +20,15 @@
  *
  *****************************************************************************/
 
-#ifndef CONNECTION_HPP
-#define CONNECTION_HPP
+#ifndef POSTGIS_CONNECTION_HPP
+#define POSTGIS_CONNECTION_HPP
 
+// mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/datasource.hpp>
+#include <mapnik/timer.hpp>
+
+// boost
 #include <boost/make_shared.hpp>
 
 // std
@@ -38,14 +43,10 @@ extern "C" {
 
 class Connection
 {
-private:
-    PGconn *conn_;
-    int cursorId;
-    bool closed_;
 public:
     Connection(std::string const& connection_str)
-        :cursorId(0),
-         closed_(false)
+        : cursorId(0),
+          closed_(false)
     {
         conn_ = PQconnectdb(connection_str.c_str());
         if (PQstatus(conn_) != CONNECTION_OK)
@@ -54,10 +55,10 @@ public:
             s << "Postgis Plugin: ";
             if (conn_ )
             {
-                std::string msg = PQerrorMessage( conn_ );
-                if ( ! msg.empty() )
+                std::string msg = PQerrorMessage(conn_);
+                if (! msg.empty())
                 {
-                    s << msg.substr( 0, msg.size() - 1 );
+                    s << msg.substr(0, msg.size() - 1);
                 }
                 else
                 {
@@ -69,39 +70,62 @@ public:
                 s << "unable to connect to postgres server";
             }
             s << "\n" << connection_str;
-            throw mapnik::datasource_exception( s.str() );
+
+            throw mapnik::datasource_exception(s.str());
+        }
+    }
+
+    ~Connection()
+    {
+        if (! closed_)
+        {
+            PQfinish(conn_);
+
+#ifdef MAPNIK_LOG
+            mapnik::log() << "postgis_connection: postgresql connection closed - " << conn_;
+#endif
+            closed_ = true;
         }
     }
 
     bool execute(const std::string& sql) const
     {
-        PGresult *result = PQexec(conn_,sql.c_str());
-        bool ok=(result && (PQresultStatus(result) == PGRES_COMMAND_OK));
+#ifdef MAPNIK_STATS
+        mapnik::progress_timer __stats__(std::clog, std::string("postgis_connection::execute ") + sql);
+#endif
+
+        PGresult *result = PQexec(conn_, sql.c_str());
+        bool ok = (result && (PQresultStatus(result) == PGRES_COMMAND_OK));
         PQclear(result);
         return ok;
     }
 
-    boost::shared_ptr<ResultSet> executeQuery(const std::string& sql,int type=0) const
+    boost::shared_ptr<ResultSet> executeQuery(const std::string& sql, int type = 0) const
     {
-        PGresult *result=0;
-        if (type==1)
+#ifdef MAPNIK_STATS
+        mapnik::progress_timer __stats__(std::clog, std::string("postgis_connection::execute_query ") + sql);
+#endif
+
+        PGresult* result = 0;
+        if (type == 1)
         {
-            result = PQexecParams(conn_,sql.c_str(),0,0,0,0,0,1);
+            result = PQexecParams(conn_,sql.c_str(), 0, 0, 0, 0, 0, 1);
         }
         else
         {
-            result = PQexec(conn_,sql.c_str());
+            result = PQexec(conn_, sql.c_str());
         }
-        if(!result || (PQresultStatus(result) != PGRES_TUPLES_OK))
+
+        if (! result || (PQresultStatus(result) != PGRES_TUPLES_OK))
         {
             std::ostringstream s;
             s << "Postgis Plugin: PSQL error";
-            if (conn_ )
+            if (conn_)
             {
-                std::string msg = PQerrorMessage( conn_ );
-                if ( ! msg.empty() )
+                std::string msg = PQerrorMessage(conn_);
+                if (! msg.empty())
                 {
-                    s << ":\n" <<  msg.substr( 0, msg.size() - 1 );
+                    s << ":\n" <<  msg.substr(0, msg.size() - 1);
                 }
 
                 s << "\nFull sql was: '" <<  sql << "'\n";
@@ -110,9 +134,13 @@ public:
             {
                 s << "unable to connect to database";
             }
+
             if (result)
+            {
                 PQclear(result);
-            throw mapnik::datasource_exception( s.str() );
+            }
+
+            throw mapnik::datasource_exception(s.str());
         }
 
         return boost::make_shared<ResultSet>(result);
@@ -120,7 +148,7 @@ public:
 
     std::string client_encoding() const
     {
-        return PQparameterStatus(conn_,"client_encoding");
+        return PQparameterStatus(conn_, "client_encoding");
     }
 
     bool isOK() const
@@ -130,11 +158,12 @@ public:
 
     void close()
     {
-        if (!closed_)
+        if (! closed_)
         {
             PQfinish(conn_);
-#ifdef MAPNIK_DEBUG
-            std::clog << "PostGIS: datasource closed, also closing connection - " << conn_ << std::endl;
+
+#ifdef MAPNIK_LOG
+            mapnik::log() << "postgis_connection: datasource closed, also closing connection - " << conn_;
 #endif
             closed_ = true;
         }
@@ -147,17 +176,10 @@ public:
         return s.str();
     }
 
-    ~Connection()
-    {
-        if (!closed_)
-        {
-            PQfinish(conn_);
-#ifdef MAPNIK_DEBUG
-            std::clog << "PostGIS: postgresql connection closed - " << conn_ << std::endl;
-#endif
-            closed_ = true;
-        }
-    }
+private:
+    PGconn *conn_;
+    int cursorId;
+    bool closed_;
 };
 
 #endif //CONNECTION_HPP
diff --git a/plugins/input/postgis/connection_manager.hpp b/plugins/input/postgis/connection_manager.hpp
index 037be7533..8cb9e58cf 100644
--- a/plugins/input/postgis/connection_manager.hpp
+++ b/plugins/input/postgis/connection_manager.hpp
@@ -20,23 +20,28 @@
  *
  *****************************************************************************/
 
-#ifndef CONNECTION_MANAGER_HPP
-#define CONNECTION_MANAGER_HPP
+#ifndef POSTGIS_CONNECTION_MANAGER_HPP
+#define POSTGIS_CONNECTION_MANAGER_HPP
 
-#include <string>
-#include <sstream>
+#include "connection.hpp"
+
+// mapnik
 #include <mapnik/pool.hpp>
 #include <mapnik/utils.hpp>
-#include "connection.hpp"
+
+// boost
 #include <boost/shared_ptr.hpp>
 #include <boost/make_shared.hpp>
 #include <boost/optional.hpp>
-
 #ifdef MAPNIK_THREADSAFE
 #include <boost/thread/mutex.hpp>
 //using boost::mutex;
 #endif
 
+// stl
+#include <string>
+#include <sstream>
+
 using mapnik::Pool;
 using mapnik::singleton;
 using mapnik::CreateStatic;
@@ -150,4 +155,4 @@ private:
     ConnectionManager& operator=(const ConnectionManager);
 };
 
-#endif //CONNECTION_MANAGER_HPP
+#endif // POSTGIS_CONNECTION_MANAGER_HPP
diff --git a/plugins/input/postgis/cursorresultset.hpp b/plugins/input/postgis/cursorresultset.hpp
index 56658a19d..5f2f77a5d 100644
--- a/plugins/input/postgis/cursorresultset.hpp
+++ b/plugins/input/postgis/cursorresultset.hpp
@@ -1,33 +1,35 @@
-#ifndef CURSORRESULTSET_HPP
-#define CURSORRESULTSET_HPP
+/*****************************************************************************
+ *
+ * This file is part of Mapnik (c++ mapping toolkit)
+ *
+ * Copyright (C) 2011 Artem Pavlenko
+ *
+ * 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
+ *
+ *****************************************************************************/
+
+#ifndef POSTGIS_CURSORRESULTSET_HPP
+#define POSTGIS_CURSORRESULTSET_HPP
+
+#include <mapnik/debug.hpp>
 
 #include "connection.hpp"
 #include "resultset.hpp"
 
 class CursorResultSet : public IResultSet
 {
-private:
-    boost::shared_ptr<Connection> conn_;
-    std::string cursorName_;
-    boost::shared_ptr<ResultSet> rs_;
-    int fetch_size_;
-    bool is_closed_;
-    int *refCount_;
-
-    void getNextResultSet()
-    {
-        std::ostringstream s;
-        s << "FETCH FORWARD " << fetch_size_ << " FROM " << cursorName_;
-#ifdef MAPNIK_DEBUG
-        std::clog << "Postgis Plugin: " << s.str() << std::endl;
-#endif
-        rs_ = conn_->executeQuery(s.str());
-        is_closed_ = false;
-#ifdef MAPNIK_DEBUG
-        std::clog << "Postgis Plugin: FETCH result (" << cursorName_ << "): " << rs_->size() << " rows" << std::endl;
-#endif
-    }
-
 public:
     CursorResultSet(boost::shared_ptr<Connection> const &conn, std::string cursorName, int fetch_count)
         : conn_(conn),
@@ -50,6 +52,15 @@ public:
         (*refCount_)++;
     }
 
+    virtual ~CursorResultSet()
+    {
+        if (--(*refCount_)==0)
+        {
+            close();
+            delete refCount_,refCount_=0;
+        }
+    }
+
     CursorResultSet& operator=(const CursorResultSet& rhs)
     {
         if (this==&rhs) return *this;
@@ -73,25 +84,18 @@ public:
         if (!is_closed_)
         {
             rs_.reset();
+
             std::ostringstream s;
             s << "CLOSE " << cursorName_;
-#ifdef MAPNIK_DEBUG
-            std::clog << "Postgis Plugin: " << s.str() << std::endl;
+
+#ifdef MAPNIK_LOG
+            mapnik::log() << "postgis_cursor_resultset: " << s.str();
 #endif
             conn_->execute(s.str());
             is_closed_ = true;
         }
     }
 
-    virtual ~CursorResultSet()
-    {
-        if (--(*refCount_)==0)
-        {
-            close();
-            delete refCount_,refCount_=0;
-        }
-    }
-
     virtual int getNumFields() const
     {
         return rs_->getNumFields();
@@ -148,6 +152,30 @@ public:
     {
         return rs_->getValue(name);
     }
+
+private:
+    void getNextResultSet()
+    {
+        std::ostringstream s;
+        s << "FETCH FORWARD " << fetch_size_ << " FROM " << cursorName_;
+
+#ifdef MAPNIK_LOG
+        mapnik::log() << "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";
+#endif
+    }
+
+    boost::shared_ptr<Connection> conn_;
+    std::string cursorName_;
+    boost::shared_ptr<ResultSet> rs_;
+    int fetch_size_;
+    bool is_closed_;
+    int *refCount_;
 };
 
-#endif //CURSORRESULTSET_HPP
+#endif // POSTGIS_CURSORRESULTSET_HPP
diff --git a/plugins/input/postgis/postgis_datasource.cpp b/plugins/input/postgis/postgis_datasource.cpp
index 59434803a..d0d1f0ab6 100644
--- a/plugins/input/postgis/postgis_datasource.cpp
+++ b/plugins/input/postgis/postgis_datasource.cpp
@@ -25,10 +25,12 @@
 #include "postgis_featureset.hpp"
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/global.hpp>
 #include <mapnik/boolean.hpp>
 #include <mapnik/sql_utils.hpp>
 #include <mapnik/util/conversions.hpp>
+#include <mapnik/timer.hpp>
 
 // boost
 #include <boost/algorithm/string.hpp>
@@ -79,8 +81,9 @@ postgis_datasource::postgis_datasource(parameters const& params, bool bind)
       // params below are for testing purposes only (will likely be removed at any time)
       intersect_min_scale_(*params_.get<int>("intersect_min_scale", 0)),
       intersect_max_scale_(*params_.get<int>("intersect_max_scale", 0))
-      //show_queries_(*params_.get<mapnik::boolean>("show_queries",false))
 {
+    log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
+
     if (table_.empty())
     {
         throw mapnik::datasource_exception("Postgis Plugin: missing <table> parameter");
@@ -105,6 +108,10 @@ void postgis_datasource::bind() const
         return;
     }
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "postgis_datasource::bind");
+#endif
+
     boost::optional<int> initial_size = params_.get<int>("initial_size", 1);
     boost::optional<int> max_size = params_.get<int>("max_size", 10);
     boost::optional<mapnik::boolean> autodetect_key_field = params_.get<mapnik::boolean>("autodetect_key_field", false);
@@ -148,6 +155,10 @@ void postgis_datasource::bind() const
             geometryColumn_ = geometry_field_;
             if (geometryColumn_.empty() || srid_ == 0)
             {
+#ifdef MAPNIK_STATS
+                mapnik::progress_timer __stats2__(std::clog, "postgis_datasource::bind(get_srid_and_geometry_column)");
+#endif
+
                 std::ostringstream s;
                 s << "SELECT f_geometry_column, srid FROM "
                   << GEOMETRY_COLUMNS <<" WHERE f_table_name='"
@@ -168,13 +179,6 @@ void postgis_datasource::bind() const
                       << "'";
                 }
 
-                /*
-                  if (show_queries_)
-                  {
-                  std::clog << boost::format("PostGIS: sending query: %s\n") % s.str();
-                  }
-                */
-
                 shared_ptr<ResultSet> rs = conn->executeQuery(s.str());
                 if (rs->next())
                 {
@@ -205,13 +209,6 @@ void postgis_datasource::bind() const
                     s << "SELECT ST_SRID(\"" << geometryColumn_ << "\") AS srid FROM "
                       << populate_tokens(table_) << " WHERE \"" << geometryColumn_ << "\" IS NOT NULL LIMIT 1;";
 
-                    /*
-                      if (show_queries_)
-                      {
-                      std::clog << boost::format("PostGIS: sending query: %s\n") % s.str();
-                      }
-                    */
-
                     shared_ptr<ResultSet> rs = conn->executeQuery(s.str());
                     if (rs->next())
                     {
@@ -232,6 +229,10 @@ void postgis_datasource::bind() const
             // detect primary key
             if (*autodetect_key_field && key_field_.empty())
             {
+#ifdef MAPNIK_STATS
+                mapnik::progress_timer __stats2__(std::clog, "postgis_datasource::bind(get_primary_key)");
+#endif
+
                 std::ostringstream s;
                 s << "SELECT a.attname, a.attnum, t.typname, t.typname in ('int2','int4','int8') "
                   "AS is_int FROM pg_class c, pg_attribute a, pg_type t, pg_namespace n, pg_index i "
@@ -267,9 +268,11 @@ void postgis_datasource::bind() const
                             {
                                 key_field_ = std::string(key_field_string);
 #ifdef MAPNIK_DEBUG
-                                std::clog << "PostGIS Plugin: auto-detected key field of '"
-                                          << key_field_ << "' on table '"
-                                          << geometry_table_ << "'\n";
+                                if (log_enabled_)
+                                {
+                                    mapnik::log() << "postgis_datasource: auto-detected key field of '"
+                                                  << key_field_ << "' on table '" << geometry_table_ << "'";
+                                }
 #endif
                             }
                         }
@@ -310,31 +313,29 @@ void postgis_datasource::bind() const
             {
                 srid_ = -1;
 
-#ifdef MAPNIK_DEBUG
-                std::clog << "Postgis Plugin: SRID warning, using srid=-1 for '" << table_ << "'" << std::endl;
+#ifdef MAPNIK_LOG
+                if (log_enabled_) mapnik::log() << "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_DEBUG
-            std::clog << "Postgis Plugin: using SRID=" << srid_ << std::endl;
-            std::clog << "Postgis Plugin: using geometry_column=" << geometryColumn_ << std::endl;
+#ifdef MAPNIK_LOG
+            if (log_enabled_)
+            {
+                mapnik::log() << "postgis_datasource: Using SRID=" << srid_;
+                mapnik::log() << "postgis_datasource: Using geometry_column=" << geometryColumn_;
+            }
 #endif
 
             // collect attribute desc
+#ifdef MAPNIK_STATS
+            mapnik::progress_timer __stats2__(std::clog, "postgis_datasource::bind(get_column_description)");
+#endif
+
             std::ostringstream s;
             s << "SELECT * FROM " << populate_tokens(table_) << " LIMIT 0";
 
-
-            /*
-              if (show_queries_)
-              {
-              std::clog << boost::format("PostGIS: sending query: %s\n") % s.str();
-              }
-            */
-
-
             shared_ptr<ResultSet> rs = conn->executeQuery(s.str());
             int count = rs->getNumFields();
             bool found_key_field = false;
@@ -400,28 +401,24 @@ void postgis_datasource::bind() const
                         desc_.add_descriptor(attribute_descriptor(fld_name, mapnik::String));
                         break;
                     default: // should not get here
-#ifdef MAPNIK_DEBUG
-                        s.str("");
-                        s << "SELECT oid, typname FROM pg_type WHERE oid = " << type_oid;
-
-                        /*
-                          if (show_queries_)
-                          {
-                          std::clog << boost::format("PostGIS: sending query: %s\n") % s.str();
-                          }
-                        */
-
-                        shared_ptr<ResultSet> rs_oid = conn->executeQuery(s.str());
-                        if (rs_oid->next())
+#ifdef MAPNIK_LOG
+                        if (log_enabled_)
                         {
-                            std::clog << "Postgis Plugin: unknown type = " << rs_oid->getValue("typname")
-                                      << " (oid:" << rs_oid->getValue("oid") << ")" << std::endl;
+                            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();
                         }
-                        else
-                        {
-                            std::clog << "Postgis Plugin: unknown oid type =" << type_oid << std::endl;
-                        }
-                        rs_oid->close();
 #endif
                         break;
                     }
@@ -435,6 +432,23 @@ void postgis_datasource::bind() const
     }
 }
 
+postgis_datasource::~postgis_datasource()
+{
+    if (is_bound_ && ! persist_connection_)
+    {
+        ConnectionManager* mgr = ConnectionManager::instance();
+        shared_ptr< Pool<Connection,ConnectionCreator> > pool = mgr->getPool(creator_.id());
+        if (pool)
+        {
+            shared_ptr<Connection> conn = pool->borrowObject();
+            if (conn)
+            {
+                conn->close();
+            }
+        }
+    }
+}
+
 std::string postgis_datasource::name()
 {
     return "postgis";
@@ -547,13 +561,6 @@ boost::shared_ptr<IResultSet> postgis_datasource::get_resultset(boost::shared_pt
 
         csql << "DECLARE " << cursor_name << " BINARY INSENSITIVE NO SCROLL CURSOR WITH HOLD FOR " << sql << " FOR READ ONLY";
 
-        /*
-          if (show_queries_)
-          {
-          std::clog << boost::format("PostGIS: sending query: %s\n") % csql.str();
-          }
-        */
-
         if (! conn->execute(csql.str()))
         {
             // TODO - better error
@@ -567,13 +574,6 @@ boost::shared_ptr<IResultSet> postgis_datasource::get_resultset(boost::shared_pt
     {
         // no cursor
 
-        /*
-          if (show_queries_)
-          {
-          std::clog << boost::format("PostGIS: sending query: %s\n") % sql;
-          }
-        */
-
         return conn->executeQuery(sql, 1);
     }
 }
@@ -585,6 +585,10 @@ featureset_ptr postgis_datasource::features(const query& q) const
         bind();
     }
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "postgis_datasource::features");
+#endif
+
     box2d<double> const& box = q.get_bbox();
     double scale_denom = q.scale_denominator();
 
@@ -678,6 +682,10 @@ featureset_ptr postgis_datasource::features_at_point(coord2d const& pt) const
         bind();
     }
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "postgis_datasource::features_at_point");
+#endif
+
     ConnectionManager* mgr = ConnectionManager::instance();
     shared_ptr< Pool<Connection,ConnectionCreator> > pool = mgr->getPool(creator_.id());
     if (pool)
@@ -836,13 +844,6 @@ box2d<double> postgis_datasource::envelope() const
                 }
             }
 
-            /*
-              if (show_queries_)
-              {
-              std::clog << boost::format("PostGIS: sending query: %s\n") % s.str();
-              }
-            */
-
             shared_ptr<ResultSet> rs = conn->executeQuery(s.str());
             if (rs->next() && ! rs->isNull(0))
             {
@@ -857,7 +858,9 @@ box2d<double> postgis_datasource::envelope() const
                 }
                 else
                 {
-                    std::clog << boost::format("Postgis Plugin: warning: could not determine extent from query: %s\n") % s.str() << std::endl;
+#ifdef MAPNIK_LOG
+                    mapnik::log() << boost::format("Mapnik LOG> postgis_datasource: Could not determine extent from query: %s") % s.str();
+#endif
                 }
             }
             rs->close();
@@ -990,20 +993,3 @@ boost::optional<mapnik::datasource::geometry_t> postgis_datasource::get_geometry
 
     return result;
 }
-
-postgis_datasource::~postgis_datasource()
-{
-    if (is_bound_ && ! persist_connection_)
-    {
-        ConnectionManager* mgr = ConnectionManager::instance();
-        shared_ptr< Pool<Connection,ConnectionCreator> > pool = mgr->getPool(creator_.id());
-        if (pool)
-        {
-            shared_ptr<Connection> conn = pool->borrowObject();
-            if (conn)
-            {
-                conn->close();
-            }
-        }
-    }
-}
diff --git a/plugins/input/postgis/postgis_datasource.hpp b/plugins/input/postgis/postgis_datasource.hpp
index f309f47fe..9333cd2e8 100644
--- a/plugins/input/postgis/postgis_datasource.hpp
+++ b/plugins/input/postgis/postgis_datasource.hpp
@@ -20,8 +20,6 @@
  *
  *****************************************************************************/
 
-//$Id: postgis.hpp 44 2005-04-22 18:53:54Z pavlenko $
-
 #ifndef POSTGIS_DATASOURCE_HPP
 #define POSTGIS_DATASOURCE_HPP
 
@@ -67,12 +65,11 @@ private:
     std::string populate_tokens(const std::string& sql) const;
     static std::string unquote(const std::string& sql);
     boost::shared_ptr<IResultSet> get_resultset(boost::shared_ptr<Connection> const &conn, std::string const& sql) const;
-    postgis_datasource(const postgis_datasource&);
-    postgis_datasource& operator=(const postgis_datasource&);
 
     static const std::string GEOMETRY_COLUMNS;
     static const std::string SPATIAL_REF_SYS;
     static const double FMAX;
+
     const std::string uri_;
     const std::string username_;
     const std::string password_;
@@ -100,4 +97,4 @@ private:
     //bool show_queries_;
 };
 
-#endif //POSTGIS_DATASOURCE_HPP
+#endif // POSTGIS_DATASOURCE_HPP
diff --git a/plugins/input/postgis/postgis_featureset.cpp b/plugins/input/postgis/postgis_featureset.cpp
index dbd8d529c..a1dacda1c 100644
--- a/plugins/input/postgis/postgis_featureset.cpp
+++ b/plugins/input/postgis/postgis_featureset.cpp
@@ -26,6 +26,7 @@
 
 // mapnik
 #include <mapnik/global.hpp>
+#include <mapnik/debug.hpp>
 #include <mapnik/wkb.hpp>
 #include <mapnik/unicode.hpp>
 #include <mapnik/sql_utils.hpp>
@@ -197,8 +198,8 @@ feature_ptr postgis_featureset::next()
 
                     default:
                     {
-#ifdef MAPNIK_DEBUG
-                        std::clog << "Postgis Plugin: uknown OID = " << oid << std::endl;
+#ifdef MAPNIK_LOG
+                        mapnik::log() << "postgis_featureset: Uknown type_oid=" << oid;
 #endif
                         break;
                     }
diff --git a/plugins/input/postgis/resultset.hpp b/plugins/input/postgis/resultset.hpp
index beab2d729..c8734f538 100644
--- a/plugins/input/postgis/resultset.hpp
+++ b/plugins/input/postgis/resultset.hpp
@@ -20,8 +20,8 @@
  *
  *****************************************************************************/
 
-#ifndef RESULTSET_HPP
-#define RESULTSET_HPP
+#ifndef POSTGIS_RESULTSET_HPP
+#define POSTGIS_RESULTSET_HPP
 
 extern "C" {
 #include "libpq-fe.h"
@@ -187,4 +187,4 @@ private:
     int *refCount_;
 };
 
-#endif //RESULTSET_HPP
+#endif // POSTGIS_RESULTSET_HPP
diff --git a/plugins/input/raster/raster_datasource.cpp b/plugins/input/raster/raster_datasource.cpp
index 183816f78..46bd384e6 100644
--- a/plugins/input/raster/raster_datasource.cpp
+++ b/plugins/input/raster/raster_datasource.cpp
@@ -26,7 +26,9 @@
 #include <boost/make_shared.hpp>
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/image_reader.hpp>
+#include <mapnik/boolean.hpp>
 
 #include "raster_featureset.hpp"
 #include "raster_info.hpp"
@@ -46,12 +48,14 @@ using mapnik::image_reader;
 DATASOURCE_PLUGIN(raster_datasource)
 
 raster_datasource::raster_datasource(const parameters& params, bool bind)
-: datasource(params),
-    desc_(*params.get<std::string>("type"), "utf-8"),
-    extent_initialized_(false)
+    : datasource(params),
+      desc_(*params.get<std::string>("type"), "utf-8"),
+      extent_initialized_(false)
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "Raster Plugin: Initializing..." << std::endl;
+    log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
+
+#ifdef MAPNIK_LOG
+    if (log_enabled_) mapnik::log() << "raster_datasource: Initializing...";
 #endif
 
     boost::optional<std::string> file = params.get<std::string>("file");
@@ -148,8 +152,8 @@ void raster_datasource::bind() const
         }
     }
 
-#ifdef MAPNIK_DEBUG
-    std::clog << "Raster Plugin: RASTER SIZE(" << width_ << "," << height_ << ")" << std::endl;
+#ifdef MAPNIK_LOG
+    if (log_enabled_) mapnik::log() << "raster_datasource: Raster size=" << width_ << "," << height_;
 #endif
 
     is_bound_ = true;
@@ -195,14 +199,14 @@ featureset_ptr raster_datasource::features(query const& q) const
     const int width  = int(ext.maxx() + 0.5) - int(ext.minx() + 0.5);
     const int height = int(ext.maxy() + 0.5) - int(ext.miny() + 0.5);
 
-#ifdef MAPNIK_DEBUG
-    std::clog << "Raster Plugin: BOX SIZE(" << width << " " << height << ")" << std::endl;
+#ifdef MAPNIK_LOG
+    if (log_enabled_) mapnik::log() << "raster_datasource: Box size=" << width << "," << height;
 #endif
 
     if (multi_tiles_)
     {
-#ifdef MAPNIK_DEBUG
-        std::clog << "Raster Plugin: MULTI-TILED policy" << std::endl;
+#ifdef MAPNIK_LOG
+        if (log_enabled_) mapnik::log() << "raster_datasource: Multi-Tiled policy";
 #endif
 
         tiled_multi_file_policy policy(filename_, format_, tile_size_, extent_, q.get_bbox(), width_, height_, tile_stride_);
@@ -211,8 +215,8 @@ featureset_ptr raster_datasource::features(query const& q) const
     }
     else if (width * height > 512*512)
     {
-#ifdef MAPNIK_DEBUG
-        std::clog << "Raster Plugin: TILED policy" << std::endl;
+#ifdef MAPNIK_LOG
+        if (log_enabled_) mapnik::log() << "raster_datasource: Tiled policy";
 #endif
 
         tiled_file_policy policy(filename_, format_, 256, extent_, q.get_bbox(), width_, height_);
@@ -221,8 +225,8 @@ featureset_ptr raster_datasource::features(query const& q) const
     }
     else
     {
-#ifdef MAPNIK_DEBUG
-        std::clog << "Raster Plugin: SINGLE FILE" << std::endl;
+#ifdef MAPNIK_LOG
+        if (log_enabled_) mapnik::log() << "raster_datasource: Single file";
 #endif
 
         raster_info info(filename_, format_, extent_, width_, height_);
@@ -234,8 +238,8 @@ featureset_ptr raster_datasource::features(query const& q) const
 
 featureset_ptr raster_datasource::features_at_point(coord2d const&) const
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "Raster Plugin: feature_at_point not supported for raster.input" << std::endl;
+#ifdef MAPNIK_LOG
+    if (log_enabled_) mapnik::log() << "raster_datasource: feature_at_point not supported";
 #endif
 
     return featureset_ptr();
diff --git a/plugins/input/raster/raster_datasource.hpp b/plugins/input/raster/raster_datasource.hpp
index 13dacff2b..5e373142a 100644
--- a/plugins/input/raster/raster_datasource.hpp
+++ b/plugins/input/raster/raster_datasource.hpp
@@ -40,7 +40,9 @@ public:
     mapnik::box2d<double> envelope() const;
     boost::optional<mapnik::datasource::geometry_t> get_geometry_type() const;
     mapnik::layer_descriptor get_descriptor() const;
+    bool log_enabled() const;
     void bind() const;
+
 private:
     mapnik::layer_descriptor desc_;
     std::string filename_;
@@ -52,9 +54,6 @@ private:
     unsigned tile_stride_;
     mutable unsigned width_;
     mutable unsigned height_;
-    //no copying
-    raster_datasource(const raster_datasource&);
-    raster_datasource& operator=(const raster_datasource&);
 };
 
 #endif // RASTER_DATASOURCE_HPP
diff --git a/plugins/input/raster/raster_featureset.cpp b/plugins/input/raster/raster_featureset.cpp
index 2ed50cd9d..6c59759d5 100644
--- a/plugins/input/raster/raster_featureset.cpp
+++ b/plugins/input/raster/raster_featureset.cpp
@@ -21,6 +21,7 @@
  *****************************************************************************/
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/image_reader.hpp>
 #include <mapnik/image_util.hpp>
 #include <mapnik/feature_factory.hpp>
@@ -69,9 +70,9 @@ feature_ptr raster_featureset<LookupPolicy>::next()
         {
             std::auto_ptr<image_reader> reader(mapnik::get_image_reader(curIter_->file(),curIter_->format()));
 
-#ifdef MAPNIK_DEBUG
-            std::clog << "Raster Plugin: READER = " << curIter_->format() << " " << curIter_->file()
-                      << " size(" << curIter_->width() << "," << curIter_->height() << ")" << std::endl;
+#ifdef MAPNIK_LOG
+            mapnik::log() << "raster_featureset: Reader=" << curIter_->format() << "," << curIter_->file()
+                          << ",size(" << curIter_->width() << "," << curIter_->height() << ")";
 #endif
 
             if (reader.get())
diff --git a/plugins/input/raster/raster_featureset.hpp b/plugins/input/raster/raster_featureset.hpp
index 22998fa32..f99b0ff9c 100644
--- a/plugins/input/raster/raster_featureset.hpp
+++ b/plugins/input/raster/raster_featureset.hpp
@@ -26,6 +26,9 @@
 #include "raster_datasource.hpp"
 #include "raster_info.hpp"
 
+// mapnik
+#include <mapnik/debug.hpp>
+
 // stl
 #include <vector>
 
@@ -137,8 +140,8 @@ public:
         double pixel_x = extent.width() / double(width);
         double pixel_y = extent.height() / double(height);
 
-#ifdef MAPNIK_DEBUG
-        std::clog << "Raster Plugin: PIXEL SIZE("<< pixel_x << "," << pixel_y << ")" << std::endl;
+#ifdef MAPNIK_LOG
+        mapnik::log() << "tiled_file_policy: Raster Plugin PIXEL SIZE("<< pixel_x << "," << pixel_y << ")";
 #endif
 
         box2d<double> e = bbox.intersect(extent);
@@ -160,8 +163,9 @@ public:
                 }
             }
         }
-#ifdef MAPNIK_DEBUG
-        std::clog << "Raster Plugin: INFO SIZE=" << infos_.size() << " " << file << std::endl;
+
+#ifdef MAPNIK_LOG
+        mapnik::log() << "tiled_file_policy: Raster Plugin INFO SIZE=" << infos_.size() << " " << file;
 #endif
     }
 
@@ -223,8 +227,8 @@ public:
         double pixel_x = extent.width() / double(width);
         double pixel_y = extent.height() / double(height);
 
-#ifdef MAPNIK_DEBUG
-        std::clog << "Raster Plugin: PIXEL SIZE("<< pixel_x << "," << pixel_y << ")" << std::endl;
+#ifdef MAPNIK_LOG
+        mapnik::log() << "tiled_multi_file_policy: Raster Plugin PIXEL SIZE(" << pixel_x << "," << pixel_y << ")";
 #endif
 
         // intersection of query with extent => new query
@@ -256,8 +260,9 @@ public:
                 }
             }
         }
-#ifdef MAPNIK_DEBUG
-        std::clog << "Raster Plugin: INFO SIZE=" << infos_.size() << " " << file_pattern << std::endl;
+
+#ifdef MAPNIK_LOG
+        mapnik::log() << "tiled_multi_file_policy: Raster Plugin INFO SIZE=" << infos_.size() << " " << file_pattern;
 #endif
     }
 
diff --git a/plugins/input/rasterlite/rasterlite_datasource.cpp b/plugins/input/rasterlite/rasterlite_datasource.cpp
index ac609f357..2fb85306d 100644
--- a/plugins/input/rasterlite/rasterlite_datasource.cpp
+++ b/plugins/input/rasterlite/rasterlite_datasource.cpp
@@ -29,6 +29,7 @@
 #include <boost/make_shared.hpp>
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/boolean.hpp>
 #include <mapnik/geom_util.hpp>
 
@@ -45,7 +46,6 @@ using mapnik::layer_descriptor;
 using mapnik::datasource_exception;
 
 
-
 /*
  * Opens a GDALDataset and returns a pointer to it.
  * Caller is responsible for calling GDALClose on it
@@ -74,8 +74,10 @@ rasterlite_datasource::rasterlite_datasource(parameters const& params, bool bind
     : datasource(params),
       desc_(*params.get<std::string>("type"),"utf-8")
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "Rasterlite Plugin: Initializing..." << std::endl;
+    log_enabled_ = *params_.get<mapnik::boolean>("log", MAPNIK_DEBUG_AS_BOOL);
+
+#ifdef MAPNIK_LOG
+    if (log_enabled_) mapnik::log() << "rasterlite_datasource: Initializing...";
 #endif
 
     boost::optional<std::string> file = params.get<std::string>("file");
@@ -118,40 +120,43 @@ void rasterlite_datasource::bind() const
 
     extent_.init(x0,y0,x1,y1);
 
-#ifdef MAPNIK_DEBUG
-    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)
+#ifdef MAPNIK_LOG
+    if (log_enabled_)
     {
-        std::string error (rasterliteGetLastError(dataset));
+        int srid, auth_srid;
+        const char *auth_name;
+        const char *ref_sys_name;
+        const char *proj4text;
 
-        rasterliteClose (dataset);
+        int tile_count;
+        double pixel_x_size, pixel_y_size;
+        int levels = rasterliteGetLevels (dataset);
 
-        throw datasource_exception(error);
-    }
-
-    std::clog << "Rasterlite Plugin: Data Source=" << rasterliteGetTablePrefix(dataset) << std::endl;
-    std::clog << "Rasterlite Plugin: SRID=" << srid << std::endl;
-    std::clog << "Rasterlite Plugin: Authority=" << auth_name << std::endl;
-    std::clog << "Rasterlite Plugin: AuthSRID=" << auth_srid << std::endl;
-    std::clog << "Rasterlite Plugin: RefSys Name=" << ref_sys_name << std::endl;
-    std::clog << "Rasterlite Plugin: Proj4Text=" << proj4text << std::endl;
-    std::clog << "Rasterlite Plugin: Extent(" << x0 << "," << y0 << " " << x1 << "," << y1 << ")" << std::endl;
-    std::clog << "Rasterlite Plugin: Levels=" << levels << std::endl;
-
-    for (int i = 0; i < levels; i++)
-    {
-        if (rasterliteGetResolution(dataset, i, &pixel_x_size, &pixel_y_size, &tile_count) == RASTERLITE_OK)
+        if (rasterliteGetSrid(dataset, &srid, &auth_name, &auth_srid, &ref_sys_name, &proj4text) != RASTERLITE_OK)
         {
-            std::clog << "Rasterlite Plugin: Level=" << i
-                      << " x=" << pixel_x_size << " y=" << pixel_y_size << " tiles=" << tile_count << std::endl;
+            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;
+            }
         }
     }
 #endif
diff --git a/plugins/input/rasterlite/rasterlite_datasource.hpp b/plugins/input/rasterlite/rasterlite_datasource.hpp
index 6c7d56072..18580935e 100644
--- a/plugins/input/rasterlite/rasterlite_datasource.hpp
+++ b/plugins/input/rasterlite/rasterlite_datasource.hpp
@@ -46,7 +46,8 @@ public:
     void bind() const;
 
 private:
-    inline void* open_dataset() const;
+    void* open_dataset() const;
+
     mutable mapnik::box2d<double> extent_;
     std::string dataset_name_;
     std::string table_name_;
diff --git a/plugins/input/rasterlite/rasterlite_featureset.cpp b/plugins/input/rasterlite/rasterlite_featureset.cpp
index c6f260233..00fc4627c 100644
--- a/plugins/input/rasterlite/rasterlite_featureset.cpp
+++ b/plugins/input/rasterlite/rasterlite_featureset.cpp
@@ -23,6 +23,7 @@
 #include "rasterlite_featureset.hpp"
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/image_util.hpp>
 #include <mapnik/feature_factory.hpp>
 
@@ -53,8 +54,8 @@ rasterlite_featureset::rasterlite_featureset(void* dataset, rasterlite_query q)
 
 rasterlite_featureset::~rasterlite_featureset()
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "Rasterlite Plugin: closing dataset" << std::endl;
+#ifdef MAPNIK_LOG
+    mapnik::log() << "rasterlite_featureset: Closing";
 #endif
 
     rasterliteClose(dataset_);
@@ -86,8 +87,8 @@ feature_ptr rasterlite_featureset::next()
 
 feature_ptr rasterlite_featureset::get_feature(mapnik::query const& q)
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "Rasterlite Plugin: get_feature" << std::endl;
+#ifdef MAPNIK_LOG
+    mapnik::log() << "rasterlite_featureset: Running get_feature";
 #endif
 
     feature_ptr feature(feature_factory::create(ctx_,1));
@@ -104,14 +105,13 @@ feature_ptr rasterlite_featureset::get_feature(mapnik::query const& q)
     const double pixel_size = (intersect.width() >= intersect.height()) ?
         (intersect.width() / (double) width) : (intersect.height() / (double) height);
 
-#ifdef MAPNIK_DEBUG
-    std::clog << "Rasterlite Plugin: Raster extent=" << raster_extent << std::endl;
-    std::clog << "Rasterlite Plugin: View extent=" << q.get_bbox() << std::endl;
-    std::clog << "Rasterlite Plugin: Intersect extent=" << intersect << std::endl;
-    std::clog << "Rasterlite Plugin: Query resolution="
-              << boost::get<0>(q.resolution())  << "," << boost::get<1>(q.resolution())  << std::endl;
-    std::clog << "Rasterlite Plugin: Size=" << width << " " << height << std::endl;
-    std::clog << "Rasterlite Plugin: Pixel Size=" << pixel_size << std::endl;
+#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;
 #endif
 
     if (width > 0 && height > 0)
@@ -145,15 +145,13 @@ feature_ptr rasterlite_featureset::get_feature(mapnik::query const& q)
 
                 free (raster);
 
-#ifdef MAPNIK_DEBUG
-                std::clog << "Rasterlite Plugin: done" << std::endl;
+#ifdef MAPNIK_LOG
+                mapnik::log() << "rasterlite_featureset: Done";
 #endif
             }
             else
             {
-#ifdef MAPNIK_DEBUG
-                std::clog << "Rasterlite Plugin: error=" << rasterliteGetLastError (dataset_) << std::endl;
-#endif
+                std::cerr << "Rasterlite Plugin: Error " << rasterliteGetLastError (dataset_) << std::endl;
             }
         }
 
diff --git a/plugins/input/shape/shape_datasource.cpp b/plugins/input/shape/shape_datasource.cpp
index 10d5b3bcb..8228a3b5d 100644
--- a/plugins/input/shape/shape_datasource.cpp
+++ b/plugins/input/shape/shape_datasource.cpp
@@ -20,8 +20,9 @@
  *
  *****************************************************************************/
 
-// mapnik
-#include <mapnik/geom_util.hpp>
+#include "shape_datasource.hpp"
+#include "shape_featureset.hpp"
+#include "shape_index_featureset.hpp"
 
 // boost
 #include <boost/version.hpp>
@@ -30,15 +31,20 @@
 #include <boost/filesystem/operations.hpp>
 #include <boost/make_shared.hpp>
 
+// mapnik
+#include <mapnik/debug.hpp>
+#include <mapnik/global.hpp>
+#include <mapnik/boolean.hpp>
+#include <mapnik/sql_utils.hpp>
+#include <mapnik/util/conversions.hpp>
+#include <mapnik/geom_util.hpp>
+#include <mapnik/timer.hpp>
+
 // stl
 #include <iostream>
 #include <fstream>
 #include <stdexcept>
 
-#include "shape_datasource.hpp"
-#include "shape_featureset.hpp"
-#include "shape_index_featureset.hpp"
-
 DATASOURCE_PLUGIN(shape_datasource)
 
 using mapnik::String;
@@ -57,6 +63,8 @@ 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");
 
@@ -78,6 +86,10 @@ void shape_datasource::bind() const
 {
     if (is_bound_) return;
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "shape_datasource::bind");
+#endif
+
     if (!boost::filesystem::exists(shape_name_ + ".shp"))
     {
         throw datasource_exception("Shape Plugin: shapefile '" + shape_name_ + ".shp' does not exist");
@@ -96,6 +108,10 @@ void shape_datasource::bind() const
 
     try
     {
+#ifdef MAPNIK_STATS
+        mapnik::progress_timer __stats2__(std::clog, "shape_datasource::bind(get_column_description)");
+#endif
+
         boost::shared_ptr<shape_io> shape_ref = boost::make_shared<shape_io>(shape_name_);
         init(*shape_ref);
         for (int i=0;i<shape_ref->dbf().num_fields();++i)
@@ -126,11 +142,11 @@ void shape_datasource::bind() const
                 break;
             }
             default:
-#ifdef MAPNIK_DEBUG
+#ifdef MAPNIK_LOG
                 // I - long
                 // G - ole
                 // + - autoincrement
-                std::clog << "Shape Plugin: unknown type " << fd.type_ << std::endl;
+                if (log_enabled_) mapnik::log() << "shape_datasource: Unknown type=" << fd.type_;
 #endif
                 break;
             }
@@ -143,17 +159,17 @@ void shape_datasource::bind() const
     }
     catch (const datasource_exception& ex)
     {
-        std::clog << "Shape Plugin: error processing field attributes, " << ex.what() << std::endl;
+        std::cerr << "Shape Plugin: error processing field attributes, " << ex.what() << std::endl;
         throw;
     }
     catch (const std::exception& ex)
     {
-        std::clog << "Shape Plugin: error processing field attributes, " << ex.what() << std::endl;
+        std::cerr << "Shape Plugin: error processing field attributes, " << ex.what() << std::endl;
         throw;
     }
     catch (...) // exception: pipe_select_interrupter: Too many open files
     {
-        std::clog << "Shape Plugin: error processing field attributes" << std::endl;
+        std::cerr << "Shape Plugin: error processing field attributes" << std::endl;
         throw;
     }
 
@@ -162,8 +178,12 @@ void shape_datasource::bind() const
 
 shape_datasource::~shape_datasource() {}
 
-void  shape_datasource::init(shape_io& shape) const
+void shape_datasource::init(shape_io& shape) const
 {
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "shape_datasource::init");
+#endif
+
     //first read header from *.shp
     int file_code=shape.shp().read_xdr_integer();
     if (file_code!=9994)
@@ -188,14 +208,17 @@ void  shape_datasource::init(shape_io& shape) const
 
     shape.shp().read_envelope(extent_);
 
-#ifdef MAPNIK_DEBUG
-    double zmin = shape.shp().read_double();
-    double zmax = shape.shp().read_double();
-    double mmin = shape.shp().read_double();
-    double mmax = shape.shp().read_double();
+#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();
 
-    std::clog << "Shape Plugin: Z min/max " << zmin << "," << zmax << std::endl;
-    std::clog << "Shape Plugin: M min/max " << mmin << "," << mmax << "\n";
+        mapnik::log() << "shape_datasource: Z min/max=" << zmin << "," << zmax;
+        mapnik::log() << "shape_datasource: M min/max=" << mmin << "," << mmax;
+    }
 #else
     shape.shp().skip(4*8);
 #endif
@@ -213,13 +236,19 @@ void  shape_datasource::init(shape_io& shape) const
     //}
     //else
     //{
-    //    std::clog << "### Notice: no .index file found for " + shape_name_ + ".shp, use the 'shapeindex' program to build an index for faster rendering\n";
+    // #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";
+    // #endif
     //}
 
-#ifdef MAPNIK_DEBUG
-    std::clog << "Shape Plugin: extent=" << extent_ << std::endl;
-    std::clog << "Shape Plugin: file_length=" << file_length_ << std::endl;
-    std::clog << "Shape Plugin: shape_type=" << shape_type_ << std::endl;
+#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_;
+    }
 #endif
 
 }
@@ -244,6 +273,10 @@ featureset_ptr shape_datasource::features(const query& q) const
 {
     if (!is_bound_) bind();
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "shape_datasource::features");
+#endif
+
     filter_in_box filter(q.get_bbox());
     if (indexed_)
     {
@@ -272,6 +305,10 @@ featureset_ptr shape_datasource::features_at_point(coord2d const& pt) const
 {
     if (!is_bound_) bind();
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "shape_datasource::features_at_point");
+#endif
+
     filter_at_point filter(pt);
     // collect all attribute names
     std::vector<attribute_descriptor> const& desc_vector = desc_.get_descriptors();
@@ -317,6 +354,10 @@ box2d<double> shape_datasource::envelope() const
 
 boost::optional<mapnik::datasource::geometry_t> shape_datasource::get_geometry_type() const
 {
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "shape_datasource::get_geometry_type");
+#endif
+
     boost::optional<mapnik::datasource::geometry_t> result;
     switch (shape_type_)
     {
diff --git a/plugins/input/shape/shape_datasource.hpp b/plugins/input/shape/shape_datasource.hpp
index e8735fc6c..159a8138e 100644
--- a/plugins/input/shape/shape_datasource.hpp
+++ b/plugins/input/shape/shape_datasource.hpp
@@ -44,7 +44,6 @@ class shape_datasource : public datasource
 public:
     shape_datasource(const parameters &params, bool bind=true);
     virtual ~shape_datasource();
-
     datasource::datasource_t type() const;
     static std::string name();
     featureset_ptr features(const query& q) const;
@@ -53,11 +52,10 @@ public:
     boost::optional<mapnik::datasource::geometry_t> get_geometry_type() const;
     layer_descriptor get_descriptor() const;
     void bind() const;
+
 private:
-    shape_datasource(const shape_datasource&);
-    shape_datasource& operator=(const shape_datasource&);
     void init(shape_io& shape) const;
-private:
+
     datasource::datasource_t type_;
     std::string shape_name_;
     mutable boost::shared_ptr<shape_io> shape_;
diff --git a/plugins/input/shape/shape_featureset.cpp b/plugins/input/shape/shape_featureset.cpp
index 6b5cbaa22..70c017914 100644
--- a/plugins/input/shape/shape_featureset.cpp
+++ b/plugins/input/shape/shape_featureset.cpp
@@ -24,6 +24,7 @@
 #include <iostream>
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/feature_factory.hpp>
 
 #include "shape_featureset.hpp"
@@ -145,8 +146,8 @@ feature_ptr shape_featureset<filterT>::next()
                 }
                 else
                 {
-#ifdef MAPNIK_DEBUG
-                    std::clog << "Shape Plugin: total shapes read=" << count_ << std::endl;
+#ifdef MAPNIK_LOG
+                    mapnik::log() << "shape_featureset: Total shapes read=" << count_;
 #endif
                     return feature_ptr();
                 }
@@ -247,7 +248,7 @@ feature_ptr shape_featureset<filterT>::next()
             }
             catch (...)
             {
-                std::clog << "Shape Plugin: error processing attributes " << std::endl;
+                std::cerr << "Shape Plugin: error processing attributes " << std::endl;
             }
         }
 
@@ -255,8 +256,8 @@ feature_ptr shape_featureset<filterT>::next()
     }
     else
     {
-#ifdef MAPNIK_DEBUG
-        std::clog << "Shape Plugin: total shapes read=" << count_ << std::endl;
+#ifdef MAPNIK_LOG
+        mapnik::log() << "shape_featureset: Total shapes read=" << count_;
 #endif
         return feature_ptr();
     }
diff --git a/plugins/input/shape/shape_index_featureset.cpp b/plugins/input/shape/shape_index_featureset.cpp
index be0b80d3c..90cf6942f 100644
--- a/plugins/input/shape/shape_index_featureset.cpp
+++ b/plugins/input/shape/shape_index_featureset.cpp
@@ -24,6 +24,7 @@
 #include <fstream>
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/feature_factory.hpp>
 
 // boost
@@ -66,8 +67,8 @@ shape_index_featureset<filterT>::shape_index_featureset(filterT const& filter,
 
     std::sort(ids_.begin(), ids_.end());
 
-#ifdef MAPNIK_DEBUG
-    std::clog << "Shape Plugin: query size=" << ids_.size() << std::endl;
+#ifdef MAPNIK_LOG
+    mapnik::log() << "shape_index_featureset: Query size=" << ids_.size();
 #endif
 
     itr_ = ids_.begin();
@@ -202,8 +203,8 @@ feature_ptr shape_index_featureset<filterT>::next()
     else
     {
 
-#ifdef MAPNIK_DEBUG
-        std::clog << "Shape Plugin: " << count_ << " features" << std::endl;
+#ifdef MAPNIK_LOG
+        mapnik::log() << "shape_index_featureset: " << count_ << " features";
 #endif
         return feature_ptr();
     }
diff --git a/plugins/input/shape/shape_io.cpp b/plugins/input/shape/shape_io.cpp
index 81677677b..6ce89fbf0 100644
--- a/plugins/input/shape/shape_io.cpp
+++ b/plugins/input/shape/shape_io.cpp
@@ -23,6 +23,7 @@
 #include "shape_io.hpp"
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/datasource.hpp>
 
 // boost
@@ -57,8 +58,8 @@ shape_io::shape_io(const std::string& shape_name, bool open_index)
         }
         catch (...)
         {
-#ifdef MAPNIK_DEBUG
-            std::clog << "Shape Plugin: warning - could not open index: '" + shape_name + INDEX + "'" << std::endl;
+#ifdef MAPNIK_LOG
+            mapnik::log() << "shape_io: Could not open index=" << shape_name << INDEX;
 #endif
         }
     }
diff --git a/plugins/input/sqlite/sqlite_connection.hpp b/plugins/input/sqlite/sqlite_connection.hpp
index 5688485b0..1a38062e2 100644
--- a/plugins/input/sqlite/sqlite_connection.hpp
+++ b/plugins/input/sqlite/sqlite_connection.hpp
@@ -29,7 +29,7 @@
 // mapnik
 #include <mapnik/datasource.hpp>
 #include <mapnik/sql_utils.hpp>
-
+#include <mapnik/timer.hpp>
 
 // boost
 #include <boost/shared_ptr.hpp>
@@ -120,6 +120,9 @@ public:
 
     boost::shared_ptr<sqlite_resultset> execute_query(const std::string& sql)
     {
+#ifdef MAPNIK_STATS
+        mapnik::progress_timer __stats__(std::clog, std::string("sqlite_resultset::execute_query ") + sql);
+#endif
         sqlite3_stmt* stmt = 0;
 
         const int rc = sqlite3_prepare_v2 (db_, sql.c_str(), -1, &stmt, 0);
@@ -133,6 +136,10 @@ public:
 
     void execute(const std::string& sql)
     {
+#ifdef MAPNIK_STATS
+        mapnik::progress_timer __stats__(std::clog, std::string("sqlite_resultset::execute ") + sql);
+#endif
+
         const int rc = sqlite3_exec(db_, sql.c_str(), 0, 0, 0);
         if (rc != SQLITE_OK)
         {
@@ -142,6 +149,10 @@ public:
 
     int execute_with_code(const std::string& sql)
     {
+#ifdef MAPNIK_STATS
+        mapnik::progress_timer __stats__(std::clog, std::string("sqlite_resultset::execute_with_code ") + sql);
+#endif
+
         const int rc = sqlite3_exec(db_, sql.c_str(), 0, 0, 0);
         return rc;
     }
diff --git a/plugins/input/sqlite/sqlite_datasource.cpp b/plugins/input/sqlite/sqlite_datasource.cpp
index b14cf1dbc..652178321 100644
--- a/plugins/input/sqlite/sqlite_datasource.cpp
+++ b/plugins/input/sqlite/sqlite_datasource.cpp
@@ -26,9 +26,11 @@
 #include "sqlite_utils.hpp"
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/boolean.hpp>
 #include <mapnik/sql_utils.hpp>
 #include <mapnik/util/geometry_to_ds_type.hpp>
+#include <mapnik/timer.hpp>
 #include <mapnik/wkb.hpp>
 
 // boost
@@ -51,23 +53,25 @@ using mapnik::parameters;
 DATASOURCE_PLUGIN(sqlite_datasource)
 
 sqlite_datasource::sqlite_datasource(parameters const& params, bool bind)
-: datasource(params),
-    extent_(),
-    extent_initialized_(false),
-    type_(datasource::Vector),
-    table_(*params_.get<std::string>("table", "")),
-    fields_(*params_.get<std::string>("fields", "*")),
-    metadata_(*params_.get<std::string>("metadata", "")),
-    geometry_table_(*params_.get<std::string>("geometry_table", "")),
-    geometry_field_(*params_.get<std::string>("geometry_field", "")),
-    index_table_(*params_.get<std::string>("index_table", "")),
-    key_field_(*params_.get<std::string>("key_field", "")),
-    row_offset_(*params_.get<int>("row_offset", 0)),
-    row_limit_(*params_.get<int>("row_limit", 0)),
-    intersects_token_("!intersects!"),
-    desc_(*params_.get<std::string>("type"), *params_.get<std::string>("encoding", "utf-8")),
-    format_(mapnik::wkbAuto)
+    : datasource(params),
+      extent_(),
+      extent_initialized_(false),
+      type_(datasource::Vector),
+      table_(*params_.get<std::string>("table", "")),
+      fields_(*params_.get<std::string>("fields", "*")),
+      metadata_(*params_.get<std::string>("metadata", "")),
+      geometry_table_(*params_.get<std::string>("geometry_table", "")),
+      geometry_field_(*params_.get<std::string>("geometry_field", "")),
+      index_table_(*params_.get<std::string>("index_table", "")),
+      key_field_(*params_.get<std::string>("key_field", "")),
+      row_offset_(*params_.get<int>("row_offset", 0)),
+      row_limit_(*params_.get<int>("row_limit", 0)),
+      intersects_token_("!intersects!"),
+      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
@@ -87,6 +91,10 @@ void sqlite_datasource::bind() const
 {
     if (is_bound_) return;
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "sqlite_datasource::bind");
+#endif
+
     boost::optional<std::string> file = params_.get<std::string>("file");
     if (! file) throw datasource_exception("Sqlite Plugin: missing <file> parameter");
 
@@ -209,8 +217,8 @@ void sqlite_datasource::bind() const
     for (std::vector<std::string>::const_iterator iter = init_statements_.begin();
          iter != init_statements_.end(); ++iter)
     {
-#ifdef MAPNIK_DEBUG
-        std::clog << "Sqlite Plugin: Execute init sql: " << *iter << std::endl;
+#ifdef MAPNIK_LOG
+        if (log_enabled_) mapnik::log() << "sqlite_datasource: Execute init sql=" << *iter;
 #endif
         dataset_->execute(*iter);
     }
@@ -283,6 +291,10 @@ void sqlite_datasource::bind() const
     has_spatial_index_ = false;
     if (use_spatial_index_)
     {
+#ifdef MAPNIK_STATS
+        mapnik::progress_timer __stats2__(std::clog, "sqlite_datasource::bind(use_spatial_index)");
+#endif
+
         if (boost::filesystem::exists(index_db))
         {
             dataset_->execute("attach database '" + index_db + "' as " + index_table_);
@@ -315,8 +327,6 @@ void sqlite_datasource::bind() const
                   dataset_->execute("attach database '" + index_db + "' as " + index_table_);
                   }
                   }
-
-
                 */
                 boost::shared_ptr<sqlite_resultset> rs = dataset_->execute_query(query.str());
                 if (sqlite_utils::create_spatial_index(index_db,index_table_,rs))
@@ -343,7 +353,6 @@ void sqlite_datasource::bind() const
 
     if (! extent_initialized_)
     {
-
         // TODO - clean this up - reducing arguments
         std::string query = populate_tokens(table_);
         if (!sqlite_utils::detect_extent(dataset_,
@@ -487,8 +496,12 @@ box2d<double> sqlite_datasource::envelope() const
 boost::optional<mapnik::datasource::geometry_t> sqlite_datasource::get_geometry_type() const
 {
     if (! is_bound_) bind();
-    boost::optional<mapnik::datasource::geometry_t> result;
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "sqlite_datasource::get_geometry_type");
+#endif
+
+    boost::optional<mapnik::datasource::geometry_t> result;
     if (dataset_)
     {
         // finally, get geometry type by querying first feature
@@ -542,6 +555,10 @@ featureset_ptr sqlite_datasource::features(query const& q) const
 {
     if (! is_bound_) bind();
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "sqlite_datasource::features");
+#endif
+
     if (dataset_)
     {
         mapnik::box2d<double> const& e = q.get_bbox();
@@ -579,7 +596,8 @@ featureset_ptr sqlite_datasource::features(query const& q) const
                                                key_field_,
                                                index_table_,
                                                geometry_table_,
-                                               intersects_token_);        }
+                                               intersects_token_);
+        }
         else
         {
             query = populate_tokens(table_);
@@ -597,9 +615,12 @@ featureset_ptr sqlite_datasource::features(query const& q) const
             s << " OFFSET " << row_offset_;
         }
 
-#ifdef MAPNIK_DEBUG
-        std::clog << "Sqlite Plugin: table: " << table_ << "\n\n";
-        std::clog << "Sqlite Plugin: query: " << s.str() << "\n\n";
+#ifdef MAPNIK_LOG
+        if (log_enabled_)
+        {
+            mapnik::log() << "sqlite_datasource: Table=" << table_;
+            mapnik::log() << "sqlite_datasource: Query=" << s.str();
+        }
 #endif
 
         boost::shared_ptr<sqlite_resultset> rs(dataset_->execute_query(s.str()));
@@ -618,6 +639,10 @@ featureset_ptr sqlite_datasource::features_at_point(coord2d const& pt) const
 {
     if (! is_bound_) bind();
 
+#ifdef MAPNIK_STATS
+    mapnik::progress_timer __stats__(std::clog, "sqlite_datasource::features_at_point");
+#endif
+
     if (dataset_)
     {
         // TODO - need tolerance
@@ -678,8 +703,8 @@ featureset_ptr sqlite_datasource::features_at_point(coord2d const& pt) const
             s << " OFFSET " << row_offset_;
         }
 
-#ifdef MAPNIK_DEBUG
-        std::clog << "Sqlite Plugin: " << s.str() << std::endl;
+#ifdef MAPNIK_LOG
+        if (log_enabled_) mapnik::log() << "sqlite_datasource: " << s.str();
 #endif
 
         boost::shared_ptr<sqlite_resultset> rs(dataset_->execute_query(s.str()));
diff --git a/plugins/input/sqlite/sqlite_datasource.hpp b/plugins/input/sqlite/sqlite_datasource.hpp
index 4fb8a0e5a..11ec7cf7f 100644
--- a/plugins/input/sqlite/sqlite_datasource.hpp
+++ b/plugins/input/sqlite/sqlite_datasource.hpp
@@ -52,11 +52,14 @@ public:
     void bind() const;
 
 private:
+    // Fill init_statements with any statements
+    // needed to attach auxillary databases
+    void parse_attachdb(std::string const& attachdb) const;
+    std::string populate_tokens(const std::string& sql) const;
 
     // FIXME: remove mutable qualifier from data members
     //        by factoring out bind() logic out from
     //        datasource impl !!!
-
     mutable mapnik::box2d<double> extent_;
     mutable bool extent_initialized_;
     mapnik::datasource::datasource_t type_;
@@ -79,11 +82,6 @@ private:
     mutable bool has_spatial_index_;
     mutable bool using_subquery_;
     mutable std::vector<std::string> init_statements_;
-
-    // Fill init_statements with any statements
-    // needed to attach auxillary databases
-    void parse_attachdb(std::string const& attachdb) const;
-    std::string populate_tokens(const std::string& sql) const;
 };
 
 #endif // MAPNIK_SQLITE_DATASOURCE_HPP
diff --git a/plugins/input/sqlite/sqlite_featureset.cpp b/plugins/input/sqlite/sqlite_featureset.cpp
index 38abcc7ae..f373641a4 100644
--- a/plugins/input/sqlite/sqlite_featureset.cpp
+++ b/plugins/input/sqlite/sqlite_featureset.cpp
@@ -22,6 +22,7 @@
 
 // mapnik
 #include <mapnik/global.hpp>
+#include <mapnik/debug.hpp>
 #include <mapnik/datasource.hpp>
 #include <mapnik/box2d.hpp>
 #include <mapnik/geometry.hpp>
@@ -124,9 +125,8 @@ feature_ptr sqlite_featureset::next()
                 break;
 
             default:
-#ifdef MAPNIK_DEBUG
-                std::clog << "Sqlite Plugin: field " << fld_name_str
-                          << " unhandled type_oid=" << type_oid << std::endl;
+#ifdef MAPNIK_LOG
+                mapnik::log() << "sqlite_featureset: Field=" << fld_name_str << " unhandled type_oid=" << type_oid;
 #endif
                 break;
             }
diff --git a/src/agg/agg_renderer.cpp b/src/agg/agg_renderer.cpp
index 9b4279114..5654a7104 100644
--- a/src/agg/agg_renderer.cpp
+++ b/src/agg/agg_renderer.cpp
@@ -76,7 +76,7 @@
 #include <boost/math/special_functions/round.hpp>
 
 // stl
-#ifdef MAPNIK_DEBUG
+#ifdef MAPNIK_LOG
 #include <iostream>
 #endif
 
@@ -174,8 +174,9 @@ void agg_renderer<T>::setup(Map const &m)
             }
         }
     }
-#ifdef MAPNIK_DEBUG
-    std::clog << "scale=" << m.scale() << "\n";
+
+#ifdef MAPNIK_LOG
+    mapnik::log() << "agg_renderer: Scale=" << m.scale();
 #endif
 }
 
@@ -185,9 +186,8 @@ agg_renderer<T>::~agg_renderer() {}
 template <typename T>
 void agg_renderer<T>::start_map_processing(Map const& map)
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "start map processing bbox="
-              << map.get_current_extent() << "\n";
+#ifdef MAPNIK_LOG
+    mapnik::log() << "agg_renderer: Start map processing bbox=" << map.get_current_extent();
 #endif
     ras_ptr->clip_box(0,0,width_,height_);
 }
@@ -195,18 +195,18 @@ void agg_renderer<T>::start_map_processing(Map const& map)
 template <typename T>
 void agg_renderer<T>::end_map_processing(Map const& )
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "end map processing\n";
+#ifdef MAPNIK_LOG
+    mapnik::log() << "agg_renderer: End map processing";
 #endif
 }
 
 template <typename T>
 void agg_renderer<T>::start_layer_processing(layer const& lay, box2d<double> const& query_extent)
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "start layer processing : " << lay.name()  << "\n";
-    std::clog << "datasource = " << lay.datasource().get() << "\n";
-    std::clog << "query_extent = " << query_extent << "\n";
+#ifdef MAPNIK_LOG
+    mapnik::log() << "agg_renderer: Start processing layer=" << lay.name();
+    mapnik::log() << "agg_renderer: -- datasource=" << lay.datasource().get();
+    mapnik::log() << "agg_renderer: -- query_extent=" << query_extent;
 #endif
     if (lay.clear_label_cache())
     {
@@ -218,8 +218,8 @@ void agg_renderer<T>::start_layer_processing(layer const& lay, box2d<double> con
 template <typename T>
 void agg_renderer<T>::end_layer_processing(layer const&)
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "end layer processing\n";
+#ifdef MAPNIK_LOG
+    mapnik::log() << "agg_renderer: End layer processing";
 #endif
 }
 
@@ -258,8 +258,6 @@ void agg_renderer<T>::render_marker(pixel_position const& pos, marker const& mar
                                                    (*marker.get_vector_data())->attributes());
 
         svg_renderer.render(*ras_ptr, sl, renb, mtx, opacity, bbox);
-
-
     }
     else
     {
diff --git a/src/agg/process_line_pattern_symbolizer.cpp b/src/agg/process_line_pattern_symbolizer.cpp
index d4a8ec437..8b2819b55 100644
--- a/src/agg/process_line_pattern_symbolizer.cpp
+++ b/src/agg/process_line_pattern_symbolizer.cpp
@@ -22,6 +22,7 @@
 //$Id$
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/agg_renderer.hpp>
 #include <mapnik/agg_rasterizer.hpp>
 #include <mapnik/agg_pattern_source.hpp>
@@ -69,7 +70,9 @@ void  agg_renderer<T>::process(line_pattern_symbolizer const& sym,
 
     if (!(*mark)->is_bitmap())
     {
-        std::clog << "### Warning only images (not '" << filename << "') are supported in the line_pattern_symbolizer\n";
+#ifdef MAPNIK_LOG
+        mapnik::log() << "agg_renderer: Only images (not '" << filename << "') are supported in the line_pattern_symbolizer";
+#endif
         return;
     }
 
diff --git a/src/agg/process_markers_symbolizer.cpp b/src/agg/process_markers_symbolizer.cpp
index 17bf44f60..d7e8613ec 100644
--- a/src/agg/process_markers_symbolizer.cpp
+++ b/src/agg/process_markers_symbolizer.cpp
@@ -19,8 +19,9 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
+// mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/agg_renderer.hpp>
 #include <mapnik/agg_rasterizer.hpp>
 #include <mapnik/expression_evaluator.hpp>
@@ -80,8 +81,11 @@ void agg_renderer<T>::process(markers_symbolizer const& sym,
         boost::optional<marker_ptr> mark = mapnik::marker_cache::instance()->find(filename, true);
         if (mark && *mark)
         {
-            if (!(*mark)->is_vector()) {
-                std::clog << "### Warning only svg markers are supported in the markers_symbolizer\n";
+            if (!(*mark)->is_vector())
+            {
+#ifdef MAPNIK_LOG
+                mapnik::log() << "agg_renderer: markers_symbolizer do not yet support SVG markers";
+#endif
                 return;
             }
             boost::optional<path_ptr> marker = (*mark)->get_vector_data();
@@ -148,8 +152,12 @@ void agg_renderer<T>::process(markers_symbolizer const& sym,
                         agg::trans_affine matrix = recenter * tr *agg::trans_affine_rotation(angle) * agg::trans_affine_translation(x, y);
                         svg_renderer.render(*ras_ptr, sl, renb, matrix, sym.get_opacity(),bbox);
                         if (writer.first)
+                        {
                             //writer.first->add_box(label_ext, feature, t_, writer.second);
-                            std::clog << "### Warning metawriter not yet supported for LINE placement\n";
+#ifdef MAPNIK_LOG
+                            mapnik::log() << "agg_renderer: metawriter do not yet supported for line placement";
+#endif
+                        }
                     }
                 }
             }
@@ -190,7 +198,7 @@ void agg_renderer<T>::process(markers_symbolizer const& sym,
             tr.transform(&x1,&y1);
             tr.transform(&x2,&y2);
             extent.init(x1,y1,x2,y2);
-            //std::clog << x1 << " " << y1 << " " << x2 << " " << y2 << "\n";
+            //mapnik::log() << "agg_renderer: " << x1 << " " << y1 << " " << x2 << " " << y2 << "\n";
         }
         else
         {
@@ -201,7 +209,7 @@ void agg_renderer<T>::process(markers_symbolizer const& sym,
             tr.transform(&x1,&y1);
             tr.transform(&x2,&y2);
             extent.init(x1,y1,x2,y2);
-            //std::clog << x1 << " " << y1 << " " << x2 << " " << y2 << "\n";
+            //mapnik::log() << "agg_renderer: " << x1 << " " << y1 << " " << x2 << " " << y2 << "\n";
         }
 
 
@@ -290,8 +298,12 @@ void agg_renderer<T>::process(markers_symbolizer const& sym,
 
                     // TODO
                     if (writer.first)
+                    {
                         //writer.first->add_box(label_ext, feature, t_, writer.second);
-                        std::clog << "### Warning metawriter not yet supported for LINE placement\n";
+#ifdef MAPNIK_LOG
+                        mapnik::log() << "agg_renderer: metawriter do not yet supported for line placement";
+#endif
+                    }
 
                     agg::conv_transform<agg::path_storage, agg::trans_affine> trans(marker, matrix);
                     ras_ptr->add_path(trans);
diff --git a/src/agg/process_polygon_pattern_symbolizer.cpp b/src/agg/process_polygon_pattern_symbolizer.cpp
index 56e1293ef..e7760646e 100644
--- a/src/agg/process_polygon_pattern_symbolizer.cpp
+++ b/src/agg/process_polygon_pattern_symbolizer.cpp
@@ -22,6 +22,7 @@
 //$Id$
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/agg_renderer.hpp>
 #include <mapnik/agg_helpers.hpp>
 #include <mapnik/agg_rasterizer.hpp>
@@ -83,14 +84,18 @@ void agg_renderer<T>::process(polygon_pattern_symbolizer const& sym,
     }
     else
     {
-        std::clog << "### Warning: file not found: " << filename << "\n";
+#ifdef MAPNIK_LOG
+        mapnik::log() << "agg_renderer: File not found=" << filename;
+#endif
     }
 
     if (!marker) return;
 
     if (!(*marker)->is_bitmap())
     {
-        std::clog << "### Warning only images (not '" << filename << "') are supported in the polygon_pattern_symbolizer\n";
+#ifdef MAPNIK_LOG
+        mapnik::log() << "agg_renderer: Only images (not '" << filename << "') are supported in the polygon_pattern_symbolizer";
+#endif
         return;
     }
 
diff --git a/src/cairo_renderer.cpp b/src/cairo_renderer.cpp
index 9a15e055d..27b3ebc74 100644
--- a/src/cairo_renderer.cpp
+++ b/src/cairo_renderer.cpp
@@ -24,6 +24,7 @@
 #if defined(HAVE_CAIRO)
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/cairo_renderer.hpp>
 #include <mapnik/image_util.hpp>
 #include <mapnik/unicode.hpp>
@@ -61,7 +62,7 @@
 
 
 // stl
-#ifdef MAPNIK_DEBUG
+#ifdef MAPNIK_LOG
 #include <iostream>
 #endif
 
@@ -642,8 +643,8 @@ cairo_renderer_base::cairo_renderer_base(Map const& m, Cairo::RefPtr<Cairo::Cont
       face_manager_(font_engine_,font_manager_),
       detector_(box2d<double>(-m.buffer_size() ,-m.buffer_size() , m.width() + m.buffer_size() ,m.height() + m.buffer_size()))
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "scale=" << m.scale() << "\n";
+#ifdef MAPNIK_LOG
+    mapnik::log() << "cairo_renderer_base: Scale=" << m.scale();
 #endif
 }
 
@@ -663,14 +664,10 @@ cairo_renderer<Cairo::Surface>::cairo_renderer(Map const& m, Cairo::RefPtr<Cairo
 
 cairo_renderer_base::~cairo_renderer_base() {}
 
-#ifdef MAPNIK_DEBUG
 void cairo_renderer_base::start_map_processing(Map const& map)
 {
-    std::clog << "start map processing bbox="
-              << map.get_current_extent() << "\n";
-#else
-    void cairo_renderer_base::start_map_processing(Map const& /*map*/)
-    {
+#ifdef MAPNIK_LOG
+    mapnik::log() << "cairo_renderer_base: Start map processing bbox=" << map.get_current_extent();
 #endif
 
 #if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 6, 0)
@@ -691,26 +688,26 @@ void cairo_renderer_base::start_map_processing(Map const& map)
     template <>
         void cairo_renderer<Cairo::Context>::end_map_processing(Map const& )
     {
-#ifdef MAPNIK_DEBUG
-        std::clog << "end map processing\n";
+#ifdef MAPNIK_LOG
+        mapnik::log() << "cairo_renderer_base: End map processing";
 #endif
     }
 
     template <>
         void cairo_renderer<Cairo::Surface>::end_map_processing(Map const& )
     {
-#ifdef MAPNIK_DEBUG
-        std::clog << "end map processing\n";
+#ifdef MAPNIK_LOG
+        mapnik::log() << "cairo_renderer_base: End map processing";
 #endif
         context_->show_page();
     }
 
     void cairo_renderer_base::start_layer_processing(layer const& lay, box2d<double> const& query_extent)
     {
-#ifdef MAPNIK_DEBUG
-        std::clog << "start layer processing : " << lay.name()  << "\n";
-        std::clog << "datasource = " << lay.datasource().get() << "\n";
-        std::clog << "query_extent = " << query_extent << "\n";
+#ifdef MAPNIK_LOG
+        mapnik::log() << "cairo_renderer_base: Start processing layer=" << lay.name() ;
+        mapnik::log() << "cairo_renderer_base: -- datasource=" << lay.datasource().get();
+        mapnik::log() << "cairo_renderer_base: -- query_extent=" << query_extent;
 #endif
         if (lay.clear_label_cache())
         {
@@ -721,8 +718,8 @@ void cairo_renderer_base::start_map_processing(Map const& map)
 
     void cairo_renderer_base::end_layer_processing(layer const&)
     {
-#ifdef MAPNIK_DEBUG
-        std::clog << "end layer processing\n";
+#ifdef MAPNIK_LOG
+        mapnik::log() << "cairo_renderer_base: End layer processing";
 #endif
     }
 
@@ -842,7 +839,6 @@ void cairo_renderer_base::start_map_processing(Map const& map)
 
                     frame->move_to(itr->get<0>(), itr->get<1>());
                     frame->line_to(itr->get<0>(), itr->get<1>() + height);
-
                 }
 
                 geom.rewind(0);
@@ -1282,8 +1278,11 @@ void cairo_renderer_base::start_map_processing(Map const& map)
             boost::optional<marker_ptr> mark = mapnik::marker_cache::instance()->find(filename, true);
             if (mark && *mark)
             {
-                if (!(*mark)->is_vector()) {
-                    std::clog << "### Warning only svg markers are supported in the markers_symbolizer\n";
+                if (!(*mark)->is_vector())
+                {
+#ifdef MAPNIK_LOG
+                    mapnik::log() << "cairo_renderer_base: markers_symbolizer does not yet support SVG markers";
+#endif
                     return;
                 }
                 boost::optional<path_ptr> marker = (*mark)->get_vector_data();
@@ -1344,8 +1343,10 @@ void cairo_renderer_base::start_map_processing(Map const& map)
                             render_marker(pixel_position(x - 0.5 * w, y - 0.5 * h), **mark, matrix, sym.get_opacity(),false);
 
                             if (writer.first)
+                            {
                                 //writer.first->add_box(label_ext, feature, t_, writer.second);
-                                std::clog << "### Warning metawriter not yet supported for LINE placement\n";
+                                std::cerr << "### Warning metawriter not yet supported for LINE placement\n";
+                            }
                         }
                     }
                     context.fill();
@@ -1469,8 +1470,10 @@ void cairo_renderer_base::start_map_processing(Map const& map)
 
                         // TODO
                         if (writer.first)
+                        {
                             //writer.first->add_box(label_ext, feature, t_, writer.second);
-                            std::clog << "### Warning metawriter not yet supported for LINE placement\n";
+                            std::cerr << "### Warning metawriter not yet supported for LINE placement\n";
+                        }
 
                         agg::conv_transform<agg::path_storage, agg::trans_affine> trans(marker, matrix);
                         context.set_color(fill_,sym.get_opacity());
diff --git a/src/datasource_cache.cpp b/src/datasource_cache.cpp
index 72af26a7c..317e99d19 100644
--- a/src/datasource_cache.cpp
+++ b/src/datasource_cache.cpp
@@ -19,11 +19,10 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id: datasource_cache.cpp 23 2005-03-22 22:16:34Z pavlenko $
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/datasource_cache.hpp>
-
 #include <mapnik/config_error.hpp>
 
 // boost
@@ -74,6 +73,7 @@ datasource_ptr datasource_cache::create(const parameters& params, bool bind)
 #ifdef MAPNIK_THREADSAFE
     mutex::scoped_lock lock(mutex_);
 #endif
+
     datasource_ptr ds;
     std::map<std::string,boost::shared_ptr<PluginInfo> >::iterator itr=plugins_.find(*type);
     if ( itr == plugins_.end() )
@@ -81,11 +81,13 @@ datasource_ptr datasource_cache::create(const parameters& params, bool bind)
         throw config_error(std::string("Could not create datasource. No plugin ") +
                            "found for type '" + * type + "' (searched in: " + plugin_directories() + ")");
     }
+
     if ( ! itr->second->handle())
     {
         throw std::runtime_error(std::string("Cannot load library: ") +
                                  lt_dlerror());
     }
+
     // http://www.mr-edd.co.uk/blog/supressing_gcc_warnings
 #ifdef __GNUC__
     __extension__
@@ -93,23 +95,26 @@ datasource_ptr datasource_cache::create(const parameters& params, bool bind)
         create_ds* create_datasource =
         reinterpret_cast<create_ds*>(lt_dlsym(itr->second->handle(), "create"));
 
-    if ( ! create_datasource)
+    if (! create_datasource)
     {
         throw std::runtime_error(std::string("Cannot load symbols: ") +
                                  lt_dlerror());
     }
-#ifdef MAPNIK_DEBUG
-    std::clog << "size = " << params.size() << "\n";
+
+#ifdef MAPNIK_LOG
+    mapnik::log() << "datasource_cache: Size=" << params.size();
+
     parameters::const_iterator i = params.begin();
-    for (;i!=params.end();++i)
+    for (; i != params.end(); ++i)
     {
-        std::clog << i->first << "=" << i->second << "\n";
+        mapnik::log() << "datasource_cache: -- " << i->first << "=" << i->second;
     }
 #endif
-    ds=datasource_ptr(create_datasource(params, bind), datasource_deleter());
 
-#ifdef MAPNIK_DEBUG
-    std::clog<<"datasource="<<ds<<" type="<<type<<std::endl;
+    ds = datasource_ptr(create_datasource(params, bind), datasource_deleter());
+
+#ifdef MAPNIK_LOG
+    mapnik::log() << "datasource_cache: Datasource=" << ds << " type=" << type;
 #endif
     return ds;
 }
@@ -175,23 +180,23 @@ void datasource_cache::register_datasources(const std::string& str)
                                 reinterpret_cast<datasource_name*>(lt_dlsym(module, "datasource_name"));
                             if (ds_name && insert(ds_name(),module))
                             {
-#ifdef MAPNIK_DEBUG
-                                std::clog << "Datasource loader: registered: " << ds_name() << std::endl;
+#ifdef MAPNIK_LOG
+                                mapnik::log() << "datasource_cache: Registered=" << ds_name();
 #endif
                                 registered_=true;
                             }
                             else if (!ds_name)
                             {
-                                std::clog << "Problem loading plugin library '" << itr->path().string() << "' (plugin is lacking compatible interface)" << std::endl;
+                                std::cerr << "Problem loading plugin library '" << itr->path().string() << "' (plugin is lacking compatible interface)" << std::endl;
                             }
                         }
                         else
                         {
 #if (BOOST_FILESYSTEM_VERSION == 3)
-                            std::clog << "Problem loading plugin library: " << itr->path().string()
+                            std::cerr << "Problem loading plugin library: " << itr->path().string()
                                       << " (dlopen failed - plugin likely has an unsatisfied dependency or incompatible ABI)" << std::endl;
 #else // v2
-                            std::clog << "Problem loading plugin library: " << itr->string()
+                            std::cerr << "Problem loading plugin library: " << itr->string()
                                       << " (dlopen failed - plugin likely has an unsatisfied dependency or incompatible ABI)" << std::endl;
 #endif
                         }
diff --git a/src/feature_style_processor.cpp b/src/feature_style_processor.cpp
index 55888d6d2..546d70776 100644
--- a/src/feature_style_processor.cpp
+++ b/src/feature_style_processor.cpp
@@ -24,12 +24,12 @@
 #include <mapnik/feature_style_processor.hpp>
 #include <mapnik/box2d.hpp>
 #include <mapnik/datasource.hpp>
+#include <mapnik/memory_datasource.hpp>
 #include <mapnik/layer.hpp>
 #include <mapnik/attribute_collector.hpp>
 #include <mapnik/expression_evaluator.hpp>
 #include <mapnik/utils.hpp>
 #include <mapnik/scale_denominator.hpp>
-
 #include <mapnik/agg_renderer.hpp>
 #include <mapnik/grid/grid_renderer.hpp>
 
@@ -92,7 +92,6 @@ feature_style_processor<Processor>::feature_style_processor(Map const& m, double
 template <typename Processor>
 void feature_style_processor<Processor>::apply()
 {
-
 #if defined(RENDERING_STATS)
     std::clog << "\n//-- starting rendering timer...\n";
     mapnik::progress_timer t(std::clog, "total map rendering");
@@ -123,7 +122,9 @@ void feature_style_processor<Processor>::apply()
     }
     catch (proj_init_error& ex)
     {
-        std::clog << "proj_init_error:" << ex.what() << "\n";
+#ifdef MAPNIK_LOG
+        mapnik::log() << "feature_style_processor: proj_init_error=" << ex.what();
+#endif
     }
 
     p.end_map_processing(m_);
@@ -153,7 +154,9 @@ void feature_style_processor<Processor>::apply(mapnik::layer const& lyr, std::se
     }
     catch (proj_init_error& ex)
     {
-        std::clog << "proj_init_error:" << ex.what() << "\n";
+#ifdef MAPNIK_LOG
+        mapnik::log() << "feature_style_processor: proj_init_error=" << ex.what();
+#endif
     }
     p.end_map_processing(m_);
 }
@@ -191,15 +194,20 @@ void feature_style_processor<Processor>::apply_to_layer(layer const& lay, Proces
     std::vector<std::string> const& style_names = lay.styles();
 
     unsigned int num_styles = style_names.size();
-    if (!num_styles) {
-        std::clog << "WARNING: No style for layer '" << lay.name() << "'\n";
+    if (! num_styles)
+    {
+#ifdef MAPNIK_LOG
+        mapnik::log() << "feature_style_processor: No style for layer=" << lay.name();
+#endif
         return;
     }
 
     mapnik::datasource_ptr ds = lay.datasource();
-    if (!ds)
+    if (! ds)
     {
-        std::clog << "WARNING: No datasource for layer '" << lay.name() << "'\n";
+#ifdef MAPNIK_LOG
+        mapnik::log() << "feature_style_processor: No datasource for layer=" << lay.name();
+#endif
         return;
     }
 
@@ -249,9 +257,11 @@ void feature_style_processor<Processor>::apply_to_layer(layer const& lay, Proces
         // forward project layer extent back into native projection
         if (!prj_trans.forward(layer_ext, PROJ_ENVELOPE_POINTS))
         {
-            std::clog << "WARNING: layer " << lay.name()
-                      << " extent " << layer_ext << " in map projection "
-                      << " did not reproject properly back to layer projection\n";
+#ifdef MAPNIK_LOG
+            mapnik::log() << "feature_style_processor: Layer=" << lay.name()
+                          << " extent=" << layer_ext << " in map projection "
+                          << " did not reproject properly back to layer projection";
+#endif
         }
     }
     else
@@ -305,8 +315,10 @@ void feature_style_processor<Processor>::apply_to_layer(layer const& lay, Proces
         boost::optional<feature_type_style const&> style=m_.find_style(style_name);
         if (!style)
         {
-            std::clog << "WARNING: style '" << style_name << "' required for layer '"
-                      << lay.name() << "' does not exist.\n";
+#ifdef MAPNIK_LOG
+            mapnik::log() << "feature_style_processor: Style=" << style_name << " required for layer="
+                          << lay.name() << " does not exist.";
+#endif
             continue;
         }
 
diff --git a/src/font_engine_freetype.cpp b/src/font_engine_freetype.cpp
index cef4551d8..afccd52dc 100644
--- a/src/font_engine_freetype.cpp
+++ b/src/font_engine_freetype.cpp
@@ -21,6 +21,7 @@
  *****************************************************************************/
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/font_engine_freetype.hpp>
 #include <mapnik/text_properties.hpp>
 #include <mapnik/graphics.hpp>
@@ -115,7 +116,10 @@ bool freetype_engine::register_font(std::string const& file_name)
                 s << "which reports a family name of '" << std::string(face->family_name) << "' and lacks a style name";
             else if (face->style_name)
                 s << "which reports a style name of '" << std::string(face->style_name) << "' and lacks a family name";
-            std::clog << s.str() << std::endl;
+
+#ifdef MAPNIK_LOG
+            mapnik::log() << "grid_renderer: " << s.str();
+#endif
         }
     }
     if (face)
@@ -328,10 +332,10 @@ box2d<double> text_renderer<T>::prepare_glyphs(text_path *path)
 
         path->vertex(&c, &x, &y, &angle);
 
-#ifdef MAPNIK_DEBUG
+#ifdef MAPNIK_LOG
         // TODO Enable when we have support for setting verbosity
-        //std::clog << "prepare_glyphs: " << c << "," << x <<
-        //    "," << y << "," << angle << std::endl;
+        //mapnik::log() << "text_renderer: prepare_glyphs="
+        //              << c << "," << x << "," << y << "," << angle;
 #endif
 
         FT_BBox glyph_bbox;
diff --git a/src/grid/grid_renderer.cpp b/src/grid/grid_renderer.cpp
index 067c23b55..2dc93991e 100644
--- a/src/grid/grid_renderer.cpp
+++ b/src/grid/grid_renderer.cpp
@@ -19,16 +19,14 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/grid/grid_rasterizer.hpp>
 #include <mapnik/grid/grid_renderer.hpp>
 #include <mapnik/grid/grid_pixfmt.hpp>
 #include <mapnik/grid/grid_pixel.hpp>
 #include <mapnik/grid/grid.hpp>
-
-
 #include <mapnik/marker.hpp>
 #include <mapnik/marker_cache.hpp>
 #include <mapnik/unicode.hpp>
@@ -39,7 +37,6 @@
 #include <mapnik/svg/svg_renderer.hpp>
 #include <mapnik/svg/svg_path_adapter.hpp>
 
-
 // boost
 #include <boost/utility.hpp>
 #include <boost/math/special_functions/round.hpp>
@@ -48,7 +45,7 @@
 #include "agg_trans_affine.h"
 
 // stl
-#ifdef MAPNIK_DEBUG
+#ifdef MAPNIK_LOG
 #include <iostream>
 #endif
 
@@ -70,8 +67,8 @@ grid_renderer<T>::grid_renderer(Map const& m, T & pixmap, double scale_factor, u
       detector_(box2d<double>(-m.buffer_size(), -m.buffer_size(), pixmap_.width() + m.buffer_size(), pixmap_.height() + m.buffer_size())),
       ras_ptr(new grid_rasterizer)
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "scale=" << m.scale() << "\n";
+#ifdef MAPNIK_LOG
+    mapnik::log() << "grid_renderer: Scale=" << m.scale();
 #endif
 }
 
@@ -79,31 +76,32 @@ template <typename T>
 grid_renderer<T>::~grid_renderer() {}
 
 template <typename T>
-void grid_renderer<T>::start_map_processing(Map const& map)
+void grid_renderer<T>::start_map_processing(Map const& m)
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "start map processing bbox="
-              << map.get_current_extent() << "\n";
+#ifdef MAPNIK_LOG
+    mapnik::log() << "grid_renderer: Start map processing bbox=" << m.get_current_extent();
 #endif
+
     ras_ptr->clip_box(0,0,width_,height_);
 }
 
 template <typename T>
-void grid_renderer<T>::end_map_processing(Map const& )
+void grid_renderer<T>::end_map_processing(Map const& m)
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "end map processing\n";
+#ifdef MAPNIK_LOG
+    mapnik::log() << "grid_renderer: End map processing";
 #endif
 }
 
 template <typename T>
 void grid_renderer<T>::start_layer_processing(layer const& lay, box2d<double> const& query_extent)
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "start layer processing : " << lay.name()  << "\n";
-    std::clog << "datasource = " << lay.datasource().get() << "\n";
-    std::clog << "query_extent = " << query_extent << "\n";
+#ifdef MAPNIK_LOG
+    mapnik::log() << "grid_renderer: Start processing layer=" << lay.name();
+    mapnik::log() << "grid_renderer: datasource=" << lay.datasource().get();
+    mapnik::log() << "grid_renderer: query_extent = " << query_extent;
 #endif
+
     if (lay.clear_label_cache())
     {
         detector_.clear();
@@ -113,8 +111,8 @@ void grid_renderer<T>::start_layer_processing(layer const& lay, box2d<double> co
 template <typename T>
 void grid_renderer<T>::end_layer_processing(layer const&)
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "end layer processing\n";
+#ifdef MAPNIK_LOG
+    mapnik::log() << "grid_renderer: End layer processing";
 #endif
 }
 
diff --git a/src/grid/process_markers_symbolizer.cpp b/src/grid/process_markers_symbolizer.cpp
index b5367cb51..c8aeaf832 100644
--- a/src/grid/process_markers_symbolizer.cpp
+++ b/src/grid/process_markers_symbolizer.cpp
@@ -22,6 +22,7 @@
 //$Id$
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/grid/grid_rasterizer.hpp>
 #include <mapnik/grid/grid_renderer.hpp>
 #include <mapnik/grid/grid_pixfmt.hpp>
@@ -29,7 +30,6 @@
 #include <mapnik/grid/grid.hpp>
 #include <mapnik/marker.hpp>
 #include <mapnik/markers_symbolizer.hpp>
-
 #include <mapnik/expression_evaluator.hpp>
 #include <mapnik/marker_cache.hpp>
 #include <mapnik/svg/svg_renderer.hpp>
@@ -108,7 +108,9 @@ void grid_renderer<T>::process(markers_symbolizer const& sym,
                 geometry_type & geom = feature->get_geometry(i);
                 if (geom.num_points() <= 1)
                 {
-                    std::clog << "### Warning svg markers not supported yet for points within markers_symbolizer\n";
+#ifdef MAPNIK_LOG
+                    mapnik::log() << "grid_renderer: markers_symbolizer points do not yet support SVG markers";
+#endif
                     continue;
                 }
 
diff --git a/src/grid/process_raster_symbolizer.cpp b/src/grid/process_raster_symbolizer.cpp
index d1414ad2b..133c6b806 100644
--- a/src/grid/process_raster_symbolizer.cpp
+++ b/src/grid/process_raster_symbolizer.cpp
@@ -22,6 +22,7 @@
 //$Id$
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/grid/grid_renderer.hpp>
 
 namespace mapnik {
@@ -32,7 +33,9 @@ void grid_renderer<T>::process(raster_symbolizer const& sym,
                                mapnik::feature_ptr const& feature,
                                proj_transform const& prj_trans)
 {
-    std::clog << "grid_renderer does not yet support raster_symbolizer\n";
+#ifdef MAPNIK_LOG
+    mapnik::log() << "grid_renderer: raster_symbolizer is not yet supported";
+#endif
 }
 
 template void grid_renderer<grid>::process(raster_symbolizer const&,
diff --git a/src/jpeg_reader.cpp b/src/jpeg_reader.cpp
index 0bea3d063..bce0ce304 100644
--- a/src/jpeg_reader.cpp
+++ b/src/jpeg_reader.cpp
@@ -39,10 +39,6 @@ extern "C"
 // std
 #include <cstdio>
 
-#ifdef MAPNIK_DEBUG
-#include <iostream>
-#endif
-
 namespace mapnik
 {
 class JpegReader : public image_reader, boost::noncopyable
diff --git a/src/libxml2_loader.cpp b/src/libxml2_loader.cpp
index bbf2d55ae..d9ea5a111 100644
--- a/src/libxml2_loader.cpp
+++ b/src/libxml2_loader.cpp
@@ -23,6 +23,7 @@
 #ifdef HAVE_LIBXML2
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/xml_loader.hpp>
 #include <mapnik/xml_node.hpp>
 #include <mapnik/config_error.hpp>
@@ -99,8 +100,7 @@ public:
         /*
           if ( ! ctx->valid )
           {
-          std::clog << "### ERROR: Failed to validate DTD."
-          << std::endl;
+            mapnik::log() << "libxml2_loader: Failed to validate DTD.";
           }
         */
         load(doc, node);
diff --git a/src/load_map.cpp b/src/load_map.cpp
index 0db27b8c3..4de988482 100644
--- a/src/load_map.cpp
+++ b/src/load_map.cpp
@@ -19,7 +19,10 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
+
 // mapnik
+#include <mapnik/debug.hpp>
+
 #include <mapnik/load_map.hpp>
 
 #include <mapnik/xml_tree.hpp>
@@ -132,7 +135,7 @@ private:
     std::map<std::string,font_set> fontsets_;
 };
 
-#include <mapnik/internal/dump_xml.hpp>
+//#include <mapnik/internal/dump_xml.hpp>
 void load_map(Map & map, std::string const& filename, bool strict)
 {
     // TODO - use xml encoding?
@@ -141,9 +144,7 @@ void load_map(Map & map, std::string const& filename, bool strict)
     read_xml(filename, tree.root());
     map_parser parser(strict, filename);
     parser.parse_map(map, tree.root(), "");
-#ifdef MAPNIK_DEBUG
-    dump_xml(tree.root());
-#endif
+    //dump_xml(tree.root());
 }
 
 void load_map_string(Map & map, std::string const& str, bool strict, std::string base_path)
@@ -228,9 +229,15 @@ void map_parser::parse_map(Map & map, xml_node const& pt, std::string const& bas
                     std::ostringstream s_err;
                     s_err << "failed to parse 'maximum-extent'";
                     if (strict_)
+                    {
                         throw config_error(s_err.str());
+                    }
                     else
-                        std::clog << "### WARNING: " << s_err.str() << std::endl;
+                    {
+#ifdef MAPNIK_LOG
+                        mapnik::log() << "map_parser: Warning - " << s_err.str();
+#endif
+                    }
                 }
             }
 
@@ -264,6 +271,7 @@ void map_parser::parse_map(Map & map, xml_node const& pt, std::string const& bas
                     {
                         throw config_error(std::string("Invalid version string encountered: '")
                             + *beg + "' in '" + *min_version_string + "'");
+
                         break;
                     }
                     if (i==2)
@@ -561,9 +569,15 @@ void map_parser::parse_layer(Map & map, xml_node const& lay)
                     std::ostringstream ss;
                     ss << "StyleName is empty in Layer: '" << lyr.name() << "'";
                     if (strict_)
+                    {
                         throw config_error(ss.str());
+                    }
                     else
-                        std::clog << "### WARNING: " << ss.str() << std::endl;
+                    {
+#ifdef MAPNIK_LOG
+                        mapnik::log() << "map_parser: Warning - " << ss.str();
+#endif
+                    }
                 }
                 else
                 {
@@ -799,9 +813,15 @@ void map_parser::parse_point_symbolizer(rule & rule, xml_node const & sym)
                         ss << "Could not parse transform from '" << transform_wkt
                            << "', expected string like: 'matrix(1, 0, 0, 1, 0, 0)'";
                         if (strict_)
+                        {
                             throw config_error(ss.str()); // value_error here?
+                        }
                         else
-                            std::clog << "### WARNING: " << ss << endl;
+                        {
+#ifdef MAPNIK_LOG
+                            mapnik::log() << "map_parser: Warning - " << ss;
+#endif
+                        }
                     }
                     boost::array<double,6> matrix;
                     tr.store_to(&matrix[0]);
@@ -818,7 +838,9 @@ void map_parser::parse_point_symbolizer(rule & rule, xml_node const & sym)
                 }
                 else
                 {
-                    std::clog << "### WARNING: " << msg << endl;
+#ifdef MAPNIK_LOG
+                    mapnik::log() << "map_parser: Warning - " << msg;
+#endif
                 }
             }
         }
@@ -866,7 +888,9 @@ void map_parser::parse_markers_symbolizer(rule & rule, xml_node const& sym)
                 }
                 else
                 {
-                    std::clog << "### WARNING: " << msg << endl;
+#ifdef MAPNIK_LOG
+                    mapnik::log() << "map_parser: Warning - " << msg;
+#endif
                 }
             }
         }
@@ -890,9 +914,15 @@ void map_parser::parse_markers_symbolizer(rule & rule, xml_node const& sym)
                 ss << "Could not parse transform from '" << transform_wkt
                    << "', expected string like: 'matrix(1, 0, 0, 1, 0, 0)'";
                 if (strict_)
+                {
                     throw config_error(ss.str()); // value_error here?
+                }
                 else
-                    std::clog << "### WARNING: " << ss << endl;
+                {
+#ifdef MAPNIK_LOG
+                    mapnik::log() << "map_parser: Warning - " << ss;
+#endif
+                }
             }
             boost::array<double,6> matrix;
             tr.store_to(&matrix[0]);
@@ -993,7 +1023,9 @@ void map_parser::parse_line_pattern_symbolizer(rule & rule, xml_node const & sym
             }
             else
             {
-                std::clog << "### WARNING: " << msg << endl;
+#ifdef MAPNIK_LOG
+                mapnik::log() << "map_parser: Warning - " << msg;
+#endif
             }
         }
     }
@@ -1057,7 +1089,9 @@ void map_parser::parse_polygon_pattern_symbolizer(rule & rule,
             }
             else
             {
-                std::clog << "### WARNING: " << msg << endl;
+#ifdef MAPNIK_LOG
+                mapnik::log() << "map_parser: Warning - " << msg;
+#endif
             }
         }
     }
@@ -1126,9 +1160,15 @@ void map_parser::parse_shield_symbolizer(rule & rule, xml_node const& sym)
                 std::stringstream ss;
                 ss << "Could not parse transform from '" << transform_wkt << "', expected string like: 'matrix(1, 0, 0, 1, 0, 0)'";
                 if (strict_)
+                {
                     throw config_error(ss.str()); // value_error here?
+                }
                 else
-                    std::clog << "### WARNING: " << ss << endl;
+                {
+#ifdef MAPNIK_LOG
+                    mapnik::log() << "map_parser: Warning - " << ss;
+#endif
+                }
             }
             boost::array<double,6> matrix;
             tr.store_to(&matrix[0]);
@@ -1197,7 +1237,9 @@ void map_parser::parse_shield_symbolizer(rule & rule, xml_node const& sym)
             }
             else
             {
-                std::clog << "### WARNING: " << msg << endl;
+#ifdef MAPNIK_LOG
+                mapnik::log() << "map_parser: Warning - " << msg;
+#endif
             }
         }
         rule.append(shield_symbol);
@@ -1253,17 +1295,17 @@ void map_parser::parse_stroke(stroke & strk, xml_node const & sym)
             if (!dash_array.empty())
             {
                 size_t size = dash_array.size();
-                if (size % 2 == 1) 
+                if (size % 2 == 1)
                     dash_array.insert(dash_array.end(),dash_array.begin(),dash_array.end());
-                
+
                 std::vector<double>::const_iterator pos = dash_array.begin();
                 while (pos != dash_array.end())
                 {
-                    if (*pos > 0.0 || *(pos+1) > 0.0) // avoid both dash and gap eq 0.0                        
+                    if (*pos > 0.0 || *(pos+1) > 0.0) // avoid both dash and gap eq 0.0
                         strk.add_dash(*pos,*(pos + 1));
                     pos +=2;
                 }
-            }   
+            }
         }
         else
         {
@@ -1518,10 +1560,10 @@ std::string map_parser::ensure_relative_to_xml(boost::optional<std::string> opt_
             boost::filesystem::path full = boost::filesystem::complete(xml_path.branch_path()/rel_path).normalize();
 #endif
 
-#ifdef MAPNIK_DEBUG
-            std::clog << "\nModifying relative paths to be relative to xml...\n";
-            std::clog << "original base path: " << *opt_path << "\n";
-            std::clog << "relative base path: " << full.string() << "\n";
+#ifdef MAPNIK_LOG
+            mapnik::log() << "map_parser: Modifying relative paths to be relative to xml...";
+            mapnik::log() << "map_parser: -- Original base path=" << *opt_path;
+            mapnik::log() << "map_parser: -- Relative base path=" << full.string();
 #endif
             return full.string();
         }
diff --git a/src/map.cpp b/src/map.cpp
index ed5ba50b3..5f908f402 100644
--- a/src/map.cpp
+++ b/src/map.cpp
@@ -20,9 +20,9 @@
  *
  *****************************************************************************/
 
-//$Id: map.cpp 17 2005-03-08 23:58:43Z pavlenko $,
+//mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/map.hpp>
-
 #include <mapnik/datasource.hpp>
 #include <mapnik/projection.hpp>
 #include <mapnik/filter_featureset.hpp>
@@ -414,9 +414,9 @@ void Map::zoom_all()
                     if (prj_trans.backward(layer_ext, PROJ_ENVELOPE_POINTS))
                     {
                         success = true;
-#ifdef MAPNIK_DEBUG
-                        std::clog << " layer " << itr->name() << " original ext: " << itr->envelope() << "\n";
-                        std::clog << " layer " << itr->name() << " transformed to map srs: " << layer_ext << "\n";
+#ifdef MAPNIK_LOG
+                        mapnik::log() << "map: Layer " << itr->name() << " original ext=" << itr->envelope();
+                        mapnik::log() << "map: Layer " << itr->name() << " transformed to map srs=" << layer_ext;
 #endif
                         if (first)
                         {
@@ -444,7 +444,7 @@ void Map::zoom_all()
         }
         catch (proj_init_error & ex)
         {
-            std::clog << "proj_init_error:" << ex.what() << "\n";
+            mapnik::log() << "map: proj_init_error=" << ex.what();
         }
     }
 }
@@ -585,8 +585,8 @@ featureset_ptr Map::query_point(unsigned index, double x, double y) const
             mapnik::datasource_ptr ds = layer.datasource();
             if (ds)
             {
-#ifdef MAPNIK_DEBUG
-                std::clog << " query at point tol = " << tol << " (" << x << "," << y << ")\n";
+#ifdef MAPNIK_LOG
+                mapnik::log() << "map: Query at point tol=" << tol << "(" << x << "," << y << ")";
 #endif
                 featureset_ptr fs = ds->features_at_point(mapnik::coord2d(x,y));
                 if (fs)
@@ -596,9 +596,7 @@ featureset_ptr Map::query_point(unsigned index, double x, double y) const
         }
         catch (...)
         {
-#ifdef MAPNIK_DEBUG
-            std::clog << "exception caught in \"query_point\"\n";
-#endif
+            std::cerr << "Exception caught in \"query_point\"" << std::endl;
         }
     }
     return featureset_ptr();
@@ -631,8 +629,8 @@ featureset_ptr Map::query_map_point(unsigned index, double x, double y) const
             mapnik::datasource_ptr ds = layer.datasource();
             if (ds)
             {
-#ifdef MAPNIK_DEBUG
-                std::clog << " query at point tol = " << tol << " (" << x << "," << y << ")\n";
+#ifdef MAPNIK_LOG
+                mapnik::log() << "map: Query at point tol=" << tol << "(" << x << "," << y << ")";
 #endif
                 featureset_ptr fs = ds->features_at_point(mapnik::coord2d(x,y));
                 if (fs)
@@ -642,9 +640,7 @@ featureset_ptr Map::query_map_point(unsigned index, double x, double y) const
         }
         catch (...)
         {
-#ifdef MAPNIK_DEBUG
-            std::clog << "exception caught in \"query_map_point\"\n";
-#endif
+            std::cerr << "Exception caught in \"query_map_point\"" << std::endl;
         }
     }
     return featureset_ptr();
diff --git a/src/memory.cpp b/src/memory.cpp
index 3ac60446f..e27852edd 100644
--- a/src/memory.cpp
+++ b/src/memory.cpp
@@ -20,8 +20,6 @@
  *
  *****************************************************************************/
 
-//$Id: memory.cpp 17 2005-03-08 23:58:43Z pavlenko $
-
 #include <mapnik/memory.hpp>
 
 namespace mapnik
@@ -48,7 +46,7 @@ void Object::operator delete(void* p)
 
 void Object::operator delete(void* , MemoryManager* )
 {
-    //std::clog <<"operator delete with Manager "<<std::hex<<p<<" "<<manager<<std::endl;
+    //std::cerr << "operator delete with Manager " << std::hex << p << " " << manager << std::endl;
 }
 
 inline size_t MemoryUtils::alignPointerSize(size_t ptrSize)
diff --git a/src/memory_datasource.cpp b/src/memory_datasource.cpp
index ad87d871c..e7a143f17 100644
--- a/src/memory_datasource.cpp
+++ b/src/memory_datasource.cpp
@@ -20,8 +20,8 @@
  *
  *****************************************************************************/
 
-//$Id$
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/memory_datasource.hpp>
 #include <mapnik/memory_featureset.hpp>
 #include <mapnik/feature_factory.hpp>
@@ -87,9 +87,11 @@ featureset_ptr memory_datasource::features(const query& q) const
 featureset_ptr memory_datasource::features_at_point(coord2d const& pt) const
 {
     box2d<double> box = box2d<double>(pt.x, pt.y, pt.x, pt.y);
-#ifdef MAPNIK_DEBUG
-    std::clog << "box=" << box << ", pt x=" << pt.x << ", y=" << pt.y << "\n";
+
+#ifdef MAPNIK_LOG
+    mapnik::log() << "memory_datasource: Box=" << box << ", Point x=" << pt.x << ",y=" << pt.y;
 #endif
+
     return boost::make_shared<memory_featureset>(box,*this);
 }
 
diff --git a/src/metawriter.cpp b/src/metawriter.cpp
index e373ea973..7df6df72a 100644
--- a/src/metawriter.cpp
+++ b/src/metawriter.cpp
@@ -21,6 +21,7 @@
  *****************************************************************************/
 
 // Mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/metawriter.hpp>
 #include <mapnik/metawriter_json.hpp>
 #include <mapnik/text_placements/base.hpp>
@@ -77,7 +78,8 @@ void metawriter_json_stream::write_header()
 
 void metawriter_json_stream::stop()
 {
-    if (count_ >= STARTED && f_) {
+    if (count_ >= STARTED && f_)
+    {
         *f_ << " ] }\n";
     }
     count_ = STOPPED;
@@ -85,8 +87,9 @@ void metawriter_json_stream::stop()
 
 metawriter_json_stream::~metawriter_json_stream()
 {
-    if (count_ >= STARTED) {
-#ifdef MAPNIK_DEBUG
+    if (count_ >= STARTED)
+    {
+#ifdef MAPNIK_LOG
         std::cerr << "WARNING: GeoJSON metawriter not stopped before destroying it.";
 #endif
         stop();
@@ -323,9 +326,11 @@ metawriter_json::metawriter_json(metawriter_properties dflt_properties, path_exp
 void metawriter_json::start(metawriter_property_map const& properties)
 {
     filename_ = path_processor<metawriter_property_map>::evaluate(*fn_, properties);
-#ifdef MAPNIK_DEBUG
-    std::clog << "Metawriter JSON: filename=" << filename_ << "\n";
+
+#ifdef MAPNIK_LOG
+    mapnik::log() << "metawriter_json: Filename=" << filename_;
 #endif
+
     metawriter_json_stream::start(properties);
 }
 
@@ -344,9 +349,9 @@ void metawriter_json::stop()
     if (f_.is_open()) {
         f_.close();
     }
-#ifdef MAPNIK_DEBUG
+#ifdef MAPNIK_LOG
     else if (count_ >= STARTED){
-        std::clog << "WARNING: File not open in metawriter_json::stop()!\n";
+        mapnik::log() << "metawriter_json: File not open when stopping";
     }
 #endif
 }
diff --git a/src/placement_finder.cpp b/src/placement_finder.cpp
index b7e797203..a9118db55 100644
--- a/src/placement_finder.cpp
+++ b/src/placement_finder.cpp
@@ -533,8 +533,8 @@ template <typename DetectorT>
 template <typename PathT>
 void placement_finder<DetectorT>::find_line_placements(PathT & shape_path)
 {
-#ifdef MAPNIK_DEBUG
-    if (!line_sizes_.empty())
+#ifdef MAPNIK_LOG
+    if (! line_sizes_.empty())
     {
         std::cerr << "WARNING: Internal error. Text contains line breaks, but line placement is used. Please file a bug report!\n";
     }
@@ -808,7 +808,7 @@ std::auto_ptr<text_path> placement_finder<DetectorT>::get_placement_offset(std::
                 index++;
                 if (index >= path_positions.size()) //Bail out if we run off the end of the shape
                 {
-                    //std::clog << "FAIL: Out of space" << std::endl;
+                    //std::cerr << "FAIL: Out of space" << std::endl;
                     return std::auto_ptr<text_path>(NULL);
                 }
                 new_x = path_positions[index].x;
@@ -845,7 +845,7 @@ std::auto_ptr<text_path> placement_finder<DetectorT>::get_placement_offset(std::
         if (p.max_char_angle_delta > 0 &&
             fabs(angle_delta) > p.max_char_angle_delta)
         {
-            //std::clog << "FAIL: Too Bendy!" << std::endl;
+            //std::cerr << "FAIL: Too Bendy!" << std::endl;
             return std::auto_ptr<text_path>(NULL);
         }
 
@@ -899,7 +899,7 @@ std::auto_ptr<text_path> placement_finder<DetectorT>::get_placement_offset(std::
         else
         {
             //Otherwise we have failed to find a placement
-            //std::clog << "FAIL: Double upside-down!" << std::endl;
+            //std::cerr << "FAIL: Double upside-down!" << std::endl;
             return std::auto_ptr<text_path>(NULL);
         }
     }
@@ -951,15 +951,15 @@ bool placement_finder<DetectorT>::test_placement(std::auto_ptr<text_path> const&
                 )
             )
         {
-            //std::clog << "No Intersects:" << !dimensions_.intersects(e) << ": " << e << " @ " << dimensions_ << std::endl;
-            //std::clog << "No Placements:" << !detector_.has_placement(e, info.get_string(), p.minimum_distance) << std::endl;
+            //std::cerr << "No Intersects:" << !dimensions_.intersects(e) << ": " << e << " @ " << dimensions_ << std::endl;
+            //std::cerr << "No Placements:" << !detector_.has_placement(e, info.get_string(), p.minimum_distance) << std::endl;
             status = false;
             break;
         }
 
         if (p.avoid_edges && !dimensions_.contains(e))
         {
-            //std::clog << "Fail avoid edges" << std::endl;
+            //std::cerr << "Fail avoid edges" << std::endl;
             status = false;
             break;
         }
diff --git a/src/png_reader.cpp b/src/png_reader.cpp
index 5e82013a2..e3c956e8a 100644
--- a/src/png_reader.cpp
+++ b/src/png_reader.cpp
@@ -20,8 +20,7 @@
  *
  *****************************************************************************/
 
-//$Id: png_reader.cpp 33 2005-04-04 13:01:03Z pavlenko $
-
+#include <mapnik/debug.hpp>
 #include <mapnik/image_reader.hpp>
 
 extern "C"
@@ -32,7 +31,7 @@ extern "C"
 #include <boost/scoped_array.hpp>
 #include <boost/utility.hpp>
 
-#ifdef MAPNIK_DEBUG
+#ifdef MAPNIK_LOG
 #include <iostream>
 #endif
 
@@ -134,9 +133,11 @@ void png_reader::init()
 
     width_=width;
     height_=height;
-#ifdef MAPNIK_DEBUG
-    std::clog<<"bit_depth="<<bit_depth_<<" color_type="<<color_type_<<std::endl;
+
+#ifdef MAPNIK_LOG
+    mapnik::log() << "png_reader: bit_depth=" << bit_depth_ << ",color_type=" << color_type_;
 #endif
+
     png_destroy_read_struct(&png_ptr,&info_ptr,0);
     fclose(fp);
 }
diff --git a/src/proj_transform.cpp b/src/proj_transform.cpp
index c52dfd7c6..ba58c1e50 100644
--- a/src/proj_transform.cpp
+++ b/src/proj_transform.cpp
@@ -133,7 +133,7 @@ bool proj_transform::backward (double * x, double * y , double * z, int point_co
         int i;
         for(i=0; i<point_count; i++) {
             x[i] = x[i] * MAXEXTENTby180;
-            y[i] = log(tan((90 + y[i]) * M_PIby360)) / D2R;
+            y[i] = std::log(tan((90 + y[i]) * M_PIby360)) / D2R;
             y[i] = y[i] * MAXEXTENTby180;
             if (x[i] > MAXEXTENT) x[i] = MAXEXTENT;
             if (x[i] < -MAXEXTENT) x[i] = -MAXEXTENT;
diff --git a/src/raster_colorizer.cpp b/src/raster_colorizer.cpp
index 1eb5a69f6..5a030c806 100644
--- a/src/raster_colorizer.cpp
+++ b/src/raster_colorizer.cpp
@@ -20,9 +20,11 @@
  *
  *****************************************************************************/
 
-//$Id:  $
-
+// mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/raster_colorizer.hpp>
+
+// stl
 #include <limits>
 
 namespace mapnik
@@ -264,17 +266,19 @@ color raster_colorizer::get_color(float value) const
     }
 
 
+#ifdef MAPNIK_LOG
     /*
-      std::clog << "get_color: " << value << "\n";
-      std::clog << "\tstopIdx: " << stopIdx << "\n";
-      std::clog << "\tnextStopIdx: " << nextStopIdx << "\n";
-      std::clog << "\tstopValue: " << stopValue << "\n";
-      std::clog << "\tnextStopValue: " << nextStopValue << "\n";
-      std::clog << "\tstopColor: " << stopColor.to_string() << "\n";
-      std::clog << "\tnextStopColor: " << nextStopColor.to_string() << "\n";
-      std::clog << "\tstopMode: " << stopMode.as_string() << "\n";
-      std::clog << "\toutputColor: " << outputColor.to_string() << "\n";
+      mapnik::log() << "raster_colorizer: get_color " << value;
+      mapnik::log() << "\tstopIdx: " << stopIdx;
+      mapnik::log() << "\tnextStopIdx: " << nextStopIdx;
+      mapnik::log() << "\tstopValue: " << stopValue;
+      mapnik::log() << "\tnextStopValue: " << nextStopValue;
+      mapnik::log() << "\tstopColor: " << stopColor.to_string();
+      mapnik::log() << "\tnextStopColor: " << nextStopColor.to_string();
+      mapnik::log() << "\tstopMode: " << stopMode.as_string();
+      mapnik::log() << "\toutputColor: " << outputColor.to_string();
     */
+#endif
 
     return outputColor;
 }
diff --git a/src/save_map.cpp b/src/save_map.cpp
index c36554b23..41699a001 100644
--- a/src/save_map.cpp
+++ b/src/save_map.cpp
@@ -207,7 +207,6 @@ public:
         // repeating the default values here.
         // maybe add a real, explicit default-ctor?
 
-
         shield_symbolizer dfl;
 
         if (sym.get_unlock_image() != dfl.get_unlock_image() || explicit_defaults_)
diff --git a/src/svg/svg_renderer.cpp b/src/svg/svg_renderer.cpp
index a68979caa..34e4695e8 100644
--- a/src/svg/svg_renderer.cpp
+++ b/src/svg/svg_renderer.cpp
@@ -19,14 +19,14 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  *****************************************************************************/
-//$Id$
 
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/svg_renderer.hpp>
 #include <mapnik/map.hpp>
 
 // stl
-#ifdef MAPNIK_DEBUG
+#ifdef MAPNIK_LOG
 #include <iostream>
 #endif
 #include <ostream>
@@ -49,8 +49,8 @@ svg_renderer<T>::~svg_renderer() {}
 template <typename T>
 void svg_renderer<T>::start_map_processing(Map const& map)
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "start map processing" << std::endl;
+#ifdef MAPNIK_LOG
+    mapnik::log() << "svg_renderer: Start map processing";
 #endif
 
     // generate XML header.
@@ -77,24 +77,24 @@ void svg_renderer<T>::end_map_processing(Map const& map)
     // generate SVG root element closing tag.
     generator_.generate_closing_root();
 
-#ifdef MAPNIK_DEBUG
-    std::clog << "end map processing" << std::endl;
+#ifdef MAPNIK_LOG
+    mapnik::log() << "svg_renderer: End map processing";
 #endif
 }
 
 template <typename T>
 void svg_renderer<T>::start_layer_processing(layer const& lay)
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "start layer processing: " << lay.name() << std::endl;
+#ifdef MAPNIK_LOG
+    mapnik::log() << "svg_renderer: Start layer processing=" << lay.name();
 #endif
 }
 
 template <typename T>
 void svg_renderer<T>::end_layer_processing(layer const& lay)
 {
-#ifdef MAPNIK_DEBUG
-    std::clog << "end layer processing: " << lay.name() << std::endl;
+#ifdef MAPNIK_LOG
+    mapnik::log() << "svg_renderer: End layer processing=" << lay.name();
 #endif
 }
 
diff --git a/src/svg_parser.cpp b/src/svg_parser.cpp
index e62f45deb..a813255f0 100644
--- a/src/svg_parser.cpp
+++ b/src/svg_parser.cpp
@@ -20,8 +20,8 @@
  *
  *****************************************************************************/
 
+#include <mapnik/debug.hpp>
 #include <mapnik/color_factory.hpp>
-
 #include <mapnik/svg/svg_parser.hpp>
 #include <mapnik/svg/svg_path_parser.hpp>
 #include <mapnik/config_error.hpp>
@@ -226,10 +226,10 @@ void svg_parser::start_element(xmlTextReaderPtr reader)
     {
         parse_gradient_stop(reader);
     }
-#ifdef MAPNIK_DEBUG
+#ifdef MAPNIK_LOG
     else if (!xmlStrEqual(name, BAD_CAST "svg"))
     {
-        std::clog << "notice: unhandled svg element: " << name << "\n";
+        mapnik::log() << "svg_parser: Unhandled svg element=" << name;
     }
 #endif
 }
diff --git a/src/text_properties.cpp b/src/text_properties.cpp
index 89e4ee6cd..7948712ab 100644
--- a/src/text_properties.cpp
+++ b/src/text_properties.cpp
@@ -120,8 +120,9 @@ void text_symbolizer_properties::from_xml(xml_node const &sym, fontset_map const
     if (max_char_angle_delta_) max_char_angle_delta=(*max_char_angle_delta_)*(M_PI/180);
 
     optional<std::string> name_ = sym.get_opt_attr<std::string>("name");
-    if (name_) {
-        std::clog << "### WARNING: Using 'name' in TextSymbolizer/ShieldSymbolizer is deprecated!\n";
+    if (name_)
+    {
+        std::cerr << "### WARNING: Using 'name' in TextSymbolizer/ShieldSymbolizer is deprecated!\n";
         set_old_style_expression(parse_expression(*name_, "utf8"));
     }
 
diff --git a/src/text_symbolizer.cpp b/src/text_symbolizer.cpp
index 75e76849b..618ebd99f 100644
--- a/src/text_symbolizer.cpp
+++ b/src/text_symbolizer.cpp
@@ -21,6 +21,7 @@
  *****************************************************************************/
 
 //mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/text_symbolizer.hpp>
 #include <mapnik/enumeration.hpp>
 
@@ -128,7 +129,11 @@ text_symbolizer& text_symbolizer::operator=(text_symbolizer const& other)
     if (this == &other)
         return *this;
     placement_options_ = other.placement_options_; /*TODO: Copy options? */
-    std::clog << "TODO: Metawriter (text_symbolizer::operator=)\n";
+
+#ifdef MAPNIK_LOG
+    mapnik::log() << "text_symbolizer: TODO - Metawriter (text_symbolizer::operator=)";
+#endif
+
     return *this;
 }
 
diff --git a/src/tiff_reader.cpp b/src/tiff_reader.cpp
index c940bcb93..0eea66482 100644
--- a/src/tiff_reader.cpp
+++ b/src/tiff_reader.cpp
@@ -20,17 +20,18 @@
  *
  *****************************************************************************/
 
-//$Id: tiff_reader.cpp 17 2005-03-08 23:58:43Z pavlenko $
 // mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/image_reader.hpp>
 #include <boost/filesystem/operations.hpp>
 
+// stl
+#include <iostream>
+
 extern "C"
 {
 #include <tiffio.h>
 }
-// stl
-#include <iostream>
 
 namespace mapnik
 {
@@ -165,7 +166,10 @@ void tiff_reader::read_generic(unsigned /*x*/,unsigned /*y*/,image_data_32& /*im
     TIFF* tif = load_if_exists(file_name_);
     if (tif)
     {
-        std::clog << "TODO:tiff is not stripped or tiled\n";
+#ifdef MAPNIK_LOG
+        mapnik::log() << "tiff_reader: TODO - tiff is not stripped or tiled";
+#endif
+
         TIFFClose(tif);
     }
 }
diff --git a/src/unicode.cpp b/src/unicode.cpp
index 5882adee3..aae9e042a 100644
--- a/src/unicode.cpp
+++ b/src/unicode.cpp
@@ -27,10 +27,6 @@
 
 #include <string>
 
-#ifdef MAPNIK_DEBUG
-#include <iostream>
-#endif
-
 namespace mapnik {
 
 transcoder::transcoder (std::string const& encoding)
diff --git a/src/wkb.cpp b/src/wkb.cpp
index 24a302697..f26390e2e 100644
--- a/src/wkb.cpp
+++ b/src/wkb.cpp
@@ -20,8 +20,8 @@
  *
  *****************************************************************************/
 
-//$Id: wkb.cpp 19 2005-03-22 13:53:27Z pavlenko $
-
+// mapnik
+#include <mapnik/debug.hpp>
 #include <mapnik/global.hpp>
 #include <mapnik/wkb.hpp>
 #include <mapnik/geom_util.hpp>
@@ -31,6 +31,8 @@
 #include <boost/utility.hpp>
 #include <boost/format.hpp>
 
+// #define MAPNIK_DEBUG_WKB
+
 namespace mapnik
 {
 struct wkb_reader : boost::noncopyable
@@ -93,18 +95,12 @@ public:
         case wkbSpatiaLite:
             byteOrder_ = (wkbByteOrder) wkb_[1];
             pos_ = 39;
-#ifdef MAPNIK_DEBUG_WKB
-            std::clog << "wkb_reader: format is wkbSpatiaLite" << std::endl;
-#endif
             break;
 
         case wkbGeneric:
         default:
             byteOrder_ = (wkbByteOrder) wkb_[0];
             pos_ = 1;
-#ifdef MAPNIK_DEBUG_WKB
-            std::clog << "wkb_reader: format is wkbGeneric" << std::endl;
-#endif
             break;
         }
 
@@ -119,8 +115,8 @@ public:
     {
         int type = read_integer();
 
-#ifdef MAPNIK_DEBUG_WKB
-        std::clog << "wkb_reader: read " << wkb_geometry_type_string(type) << " " << type << std::endl;
+#if defined(MAPNIK_LOG) && defined(MAPNIK_DEBUG_WKB)
+        mapnik::log() << "wkb_reader: Read=" << wkb_geometry_type_string(type) << "," << type;
 #endif
 
         switch (type)
@@ -409,7 +405,7 @@ private:
         }
     }
 
-#ifdef MAPNIK_DEBUG_WKB
+#if defined(MAPNIK_LOG) && defined(MAPNIK_DEBUG_WKB)
     std::string wkb_geometry_type_string(int type)
     {
         std::stringstream s;
diff --git a/tests/python_tests/csv_test.py b/tests/python_tests/csv_test.py
index b7411d5d9..ae86d37ac 100644
--- a/tests/python_tests/csv_test.py
+++ b/tests/python_tests/csv_test.py
@@ -53,14 +53,22 @@ if 'csv' in mapnik.DatasourceCache.instance().plugin_names():
         attr = {'City': u'New York, NY', 'geo_accuracy': u'house', 'Phone': u'(212) 334-0711', 'Address': u'19 Elizabeth Street', 'Precinct': u'5th Precinct', 'geo_longitude': -70, 'geo_latitude': 40}
         eq_(feat.attributes,attr)
         eq_(len(ds.all_features()),2)
-        eq_(ds.describe(),{'geometry_type': mapnik.DataGeometryType.Point, 'type': mapnik.DataType.Vector, 'name': 'csv', 'encoding': 'utf-8'})
+        desc = ds.describe()
+        eq_(desc['geometry_type'],mapnik.DataGeometryType.Point)
+        eq_(desc['name'],'csv')
+        eq_(desc['type'],mapnik.DataType.Vector)
+        eq_(desc['encoding'],'utf-8')
 
     def test_skipping_blank_rows(**kwargs):
         ds = get_csv_ds('blank_rows.csv')
         eq_(ds.fields(),['x','y','name'])
         eq_(ds.field_types(),['int','int','str'])
         eq_(len(ds.all_features()),2)
-        eq_(ds.describe(),{'geometry_type': mapnik.DataGeometryType.Point, 'type': mapnik.DataType.Vector, 'name': 'csv', 'encoding': 'utf-8'})
+        desc = ds.describe()
+        eq_(desc['geometry_type'],mapnik.DataGeometryType.Point)
+        eq_(desc['name'],'csv')
+        eq_(desc['type'],mapnik.DataType.Vector)
+        eq_(desc['encoding'],'utf-8')
 
     def test_empty_rows(**kwargs):
         ds = get_csv_ds('empty_rows.csv')
@@ -76,7 +84,11 @@ if 'csv' in mapnik.DatasourceCache.instance().plugin_names():
             eq_(len(feat),10)
             eq_(feat['empty_column'],u'')
             feat = fs.next()
-        eq_(ds.describe(),{'geometry_type': mapnik.DataGeometryType.Point, 'type': mapnik.DataType.Vector, 'name': 'csv', 'encoding': 'utf-8'})
+        desc = ds.describe()
+        eq_(desc['geometry_type'],mapnik.DataGeometryType.Point)
+        eq_(desc['name'],'csv')
+        eq_(desc['type'],mapnik.DataType.Vector)
+        eq_(desc['encoding'],'utf-8')
 
     def test_slashes(**kwargs):
         ds = get_csv_ds('has_attributes_with_slashes.csv')
@@ -85,7 +97,11 @@ if 'csv' in mapnik.DatasourceCache.instance().plugin_names():
         eq_(fs[0].attributes,{'x':0,'y':0,'name':u'a/a'})
         eq_(fs[1].attributes,{'x':1,'y':4,'name':u'b/b'})
         eq_(fs[2].attributes,{'x':10,'y':2.5,'name':u'c/c'})
-        eq_(ds.describe(),{'geometry_type': mapnik.DataGeometryType.Point, 'type': mapnik.DataType.Vector, 'name': 'csv', 'encoding': 'utf-8'})
+        desc = ds.describe()
+        eq_(desc['geometry_type'],mapnik.DataGeometryType.Point)
+        eq_(desc['name'],'csv')
+        eq_(desc['type'],mapnik.DataType.Vector)
+        eq_(desc['encoding'],'utf-8')
 
     def test_wkt_field(**kwargs):
         ds = get_csv_ds('wkt.csv')
@@ -113,7 +129,11 @@ if 'csv' in mapnik.DatasourceCache.instance().plugin_names():
         eq_(fs[6].geometries()[0].type(),mapnik.DataGeometryType.Polygon)
         eq_(len(fs[7].geometries()),2)
         eq_(fs[7].geometries()[0].type(),mapnik.DataGeometryType.Polygon)
-        eq_(ds.describe(),{'geometry_type': mapnik.DataGeometryType.Collection, 'type': mapnik.DataType.Vector, 'name': 'csv', 'encoding': 'utf-8'})
+        desc = ds.describe()
+        eq_(desc['geometry_type'],mapnik.DataGeometryType.Collection)
+        eq_(desc['name'],'csv')
+        eq_(desc['type'],mapnik.DataType.Vector)
+        eq_(desc['encoding'],'utf-8')
 
     def test_handling_of_missing_header(**kwargs):
         ds = get_csv_ds('missing_header.csv')
@@ -122,7 +142,11 @@ if 'csv' in mapnik.DatasourceCache.instance().plugin_names():
         fs = ds.featureset()
         feat = fs.next()
         eq_(feat['_4'],'missing')
-        eq_(ds.describe(),{'geometry_type': mapnik.DataGeometryType.Point, 'type': mapnik.DataType.Vector, 'name': 'csv', 'encoding': 'utf-8'})
+        desc = ds.describe()
+        eq_(desc['geometry_type'],mapnik.DataGeometryType.Point)
+        eq_(desc['name'],'csv')
+        eq_(desc['type'],mapnik.DataType.Vector)
+        eq_(desc['encoding'],'utf-8')
 
     def test_handling_of_headers_that_are_numbers(**kwargs):
         ds = get_csv_ds('numbers_for_headers.csv')
@@ -148,7 +172,11 @@ if 'csv' in mapnik.DatasourceCache.instance().plugin_names():
         eq_(fs[2]['label'],"0,5")
         eq_(fs[3]['label'],"5,0")
         eq_(fs[4]['label'],"2.5,2.5")
-        eq_(ds.describe(),{'geometry_type': mapnik.DataGeometryType.Point, 'type': mapnik.DataType.Vector, 'name': 'csv', 'encoding': 'utf-8'})
+        desc = ds.describe()
+        eq_(desc['geometry_type'],mapnik.DataGeometryType.Point)
+        eq_(desc['name'],'csv')
+        eq_(desc['type'],mapnik.DataType.Vector)
+        eq_(desc['encoding'],'utf-8')
 
     def test_windows_newlines(**kwargs):
         ds = get_csv_ds('windows_newlines.csv')
@@ -160,7 +188,11 @@ if 'csv' in mapnik.DatasourceCache.instance().plugin_names():
         eq_(feat['x'],1)
         eq_(feat['y'],10)
         eq_(feat['z'],9999.9999)
-        eq_(ds.describe(),{'geometry_type': mapnik.DataGeometryType.Point, 'type': mapnik.DataType.Vector, 'name': 'csv', 'encoding': 'utf-8'})
+        desc = ds.describe()
+        eq_(desc['geometry_type'],mapnik.DataGeometryType.Point)
+        eq_(desc['name'],'csv')
+        eq_(desc['type'],mapnik.DataType.Vector)
+        eq_(desc['encoding'],'utf-8')
 
     def test_mac_newlines(**kwargs):
         ds = get_csv_ds('windows_newlines.csv')
@@ -172,7 +204,11 @@ if 'csv' in mapnik.DatasourceCache.instance().plugin_names():
         eq_(feat['x'],1)
         eq_(feat['y'],10)
         eq_(feat['z'],9999.9999)
-        eq_(ds.describe(),{'geometry_type': mapnik.DataGeometryType.Point, 'type': mapnik.DataType.Vector, 'name': 'csv', 'encoding': 'utf-8'})
+        desc = ds.describe()
+        eq_(desc['geometry_type'],mapnik.DataGeometryType.Point)
+        eq_(desc['name'],'csv')
+        eq_(desc['type'],mapnik.DataType.Vector)
+        eq_(desc['encoding'],'utf-8')
 
     def test_tabs(**kwargs):
         ds = get_csv_ds('tabs_in_csv.csv')
@@ -183,7 +219,11 @@ if 'csv' in mapnik.DatasourceCache.instance().plugin_names():
         eq_(feat['x'],-122)
         eq_(feat['y'],48)
         eq_(feat['z'],0)
-        eq_(ds.describe(),{'geometry_type': mapnik.DataGeometryType.Point, 'type': mapnik.DataType.Vector, 'name': 'csv', 'encoding': 'utf-8'})
+        desc = ds.describe()
+        eq_(desc['geometry_type'],mapnik.DataGeometryType.Point)
+        eq_(desc['name'],'csv')
+        eq_(desc['type'],mapnik.DataType.Vector)
+        eq_(desc['encoding'],'utf-8')
 
     def test_separator_pipes(**kwargs):
         ds = get_csv_ds('pipe_delimiters.csv')
@@ -194,7 +234,11 @@ if 'csv' in mapnik.DatasourceCache.instance().plugin_names():
         eq_(feat['x'],0)
         eq_(feat['y'],0)
         eq_(feat['z'],'hello')
-        eq_(ds.describe(),{'geometry_type': mapnik.DataGeometryType.Point, 'type': mapnik.DataType.Vector, 'name': 'csv', 'encoding': 'utf-8'})
+        desc = ds.describe()
+        eq_(desc['geometry_type'],mapnik.DataGeometryType.Point)
+        eq_(desc['name'],'csv')
+        eq_(desc['type'],mapnik.DataType.Vector)
+        eq_(desc['encoding'],'utf-8')
 
     def test_separator_semicolon(**kwargs):
         ds = get_csv_ds('semicolon_delimiters.csv')
@@ -205,7 +249,11 @@ if 'csv' in mapnik.DatasourceCache.instance().plugin_names():
         eq_(feat['x'],0)
         eq_(feat['y'],0)
         eq_(feat['z'],'hello')
-        eq_(ds.describe(),{'geometry_type': mapnik.DataGeometryType.Point, 'type': mapnik.DataType.Vector, 'name': 'csv', 'encoding': 'utf-8'})
+        desc = ds.describe()
+        eq_(desc['geometry_type'],mapnik.DataGeometryType.Point)
+        eq_(desc['name'],'csv')
+        eq_(desc['type'],mapnik.DataType.Vector)
+        eq_(desc['encoding'],'utf-8')
 
     def test_that_null_and_bool_keywords_are_empty_strings(**kwargs):
         ds = get_csv_ds('nulls_and_booleans_as_strings.csv')
@@ -223,7 +271,8 @@ if 'csv' in mapnik.DatasourceCache.instance().plugin_names():
         eq_(feat['y'],0)
         eq_(feat['null'],'')
         eq_(feat['boolean'],'false')
-        eq_(ds.describe(),{'geometry_type': mapnik.DataGeometryType.Point, 'type': mapnik.DataType.Vector, 'name': 'csv', 'encoding': 'utf-8'})
+        desc = ds.describe()
+        eq_(desc['geometry_type'],mapnik.DataGeometryType.Point)
 
     @raises(RuntimeError)
     def test_that_nonexistant_query_field_throws(**kwargs):
@@ -237,7 +286,8 @@ if 'csv' in mapnik.DatasourceCache.instance().plugin_names():
         # also add an invalid one, triggering throw
         query.add_property_name('bogus')
         fs = ds.features(query)
-        eq_(ds.describe(),{'geometry_type': mapnik.DataGeometryType.Point, 'type': mapnik.DataType.Vector, 'name': 'csv', 'encoding': 'utf-8'})
+        desc = ds.describe()
+        eq_(desc['geometry_type'],mapnik.DataGeometryType.Point)
 
     def test_that_leading_zeros_mean_strings(**kwargs):
         ds = get_csv_ds('leading_zeros.csv')
@@ -257,7 +307,8 @@ if 'csv' in mapnik.DatasourceCache.instance().plugin_names():
         eq_(feat['x'],0)
         eq_(feat['y'],0)
         eq_(feat['fips'],'005')
-        eq_(ds.describe(),{'geometry_type': mapnik.DataGeometryType.Point, 'type': mapnik.DataType.Vector, 'name': 'csv', 'encoding': 'utf-8'})
+        desc = ds.describe()
+        eq_(desc['geometry_type'],mapnik.DataGeometryType.Point)
 
     def test_advanced_geometry_detection(**kwargs):
         ds = get_csv_ds('point_wkt.csv')
diff --git a/tests/python_tests/datasource_test.py b/tests/python_tests/datasource_test.py
index a6c865cd5..45bc11604 100644
--- a/tests/python_tests/datasource_test.py
+++ b/tests/python_tests/datasource_test.py
@@ -19,7 +19,11 @@ def test_field_listing():
         ds = mapnik.Shapefile(file='../data/shp/poly.shp')
         fields = ds.fields()
         eq_(fields, ['AREA', 'EAS_ID', 'PRFEDEA'])
-        eq_(ds.describe(),{'geometry_type': mapnik.DataGeometryType.Polygon, 'type': mapnik.DataType.Vector, 'name': 'shape', 'encoding': 'utf-8'})
+        desc = ds.describe()
+        eq_(desc['geometry_type'],mapnik.DataGeometryType.Polygon)
+        eq_(desc['name'],'shape')
+        eq_(desc['type'],mapnik.DataType.Vector)
+        eq_(desc['encoding'],'utf-8')
 
 def test_total_feature_count_shp():
     if 'shape' in mapnik.DatasourceCache.instance().plugin_names():
@@ -31,7 +35,11 @@ def test_total_feature_count_shp():
 def test_total_feature_count_json():
     if 'ogr' in mapnik.DatasourceCache.instance().plugin_names():
         ds = mapnik.Ogr(file='../data/json/points.json',layer_by_index=0)
-        eq_(ds.describe(),{'geometry_type': mapnik.DataGeometryType.Point, 'type': mapnik.DataType.Vector, 'name': 'ogr', 'encoding': 'utf-8'})
+        desc = ds.describe()
+        eq_(desc['geometry_type'],mapnik.DataGeometryType.Point)
+        eq_(desc['name'],'ogr')
+        eq_(desc['type'],mapnik.DataType.Vector)
+        eq_(desc['encoding'],'utf-8')
         features = ds.all_features()
         num_feats = len(features)
         eq_(num_feats, 5)
@@ -39,7 +47,11 @@ def test_total_feature_count_json():
 def test_sqlite_reading():
     if 'sqlite' in mapnik.DatasourceCache.instance().plugin_names():
         ds = mapnik.SQLite(file='../data/sqlite/world.sqlite',table_by_index=0)
-        eq_(ds.describe(),{'geometry_type': mapnik.DataGeometryType.Polygon, 'type': mapnik.DataType.Vector, 'name': 'sqlite', 'encoding': 'utf-8'})
+        desc = ds.describe()
+        eq_(desc['geometry_type'],mapnik.DataGeometryType.Polygon)
+        eq_(desc['name'],'sqlite')
+        eq_(desc['type'],mapnik.DataType.Vector)
+        eq_(desc['encoding'],'utf-8')
         features = ds.all_features()
         num_feats = len(features)
         eq_(num_feats, 245)
diff --git a/workspace/mapnik.pro b/workspace/mapnik.pro
index 6afa5ce50..ae9afc104 100644
--- a/workspace/mapnik.pro
+++ b/workspace/mapnik.pro
@@ -9,9 +9,15 @@ TEMPLATE = lib
 INCLUDEPATH = \
     ../deps/agg/include \
     ../deps/threadpool \
-    ../include/mapnik
+    ../include \
 
 HEADERS += \
+    ../include/mapnik/formatting/base.hpp \
+    ../include/mapnik/formatting/expression.hpp \
+    ../include/mapnik/formatting/format.hpp \
+    ../include/mapnik/formatting/list.hpp \
+    ../include/mapnik/formatting/registry.hpp \
+    ../include/mapnik/formatting/text.hpp \
     ../include/mapnik/grid/grid.hpp \
     ../include/mapnik/grid/grid_pixel.hpp \
     ../include/mapnik/grid/grid_pixfmt.hpp \
@@ -20,6 +26,13 @@ HEADERS += \
     ../include/mapnik/grid/grid_rendering_buffer.hpp \
     ../include/mapnik/grid/grid_util.hpp \
     ../include/mapnik/grid/grid_view.hpp \
+    ../include/mapnik/internal/dump_xml.hpp \
+    ../include/mapnik/json/feature_collection_grammar.hpp \
+    ../include/mapnik/json/feature_collection_parser.hpp \
+    ../include/mapnik/json/feature_generator_grammar.hpp \
+    ../include/mapnik/json/feature_grammar.hpp \
+    ../include/mapnik/json/geojson_generator.hpp \
+    ../include/mapnik/json/geometry_generator_grammar.hpp \
     ../include/mapnik/svg/svg_converter.hpp \
     ../include/mapnik/svg/svg_generator.hpp \
     ../include/mapnik/svg/svg_output_attributes.hpp \
@@ -35,30 +48,48 @@ HEADERS += \
     ../include/mapnik/svg/svg_renderer.hpp \
     ../include/mapnik/svg/svg_storage.hpp \
     ../include/mapnik/svg/svg_transform_grammar.hpp \
+    ../include/mapnik/text_placements/base.hpp \
+    ../include/mapnik/text_placements/dummy.hpp \
+    ../include/mapnik/text_placements/list.hpp \
+    ../include/mapnik/text_placements/registry.hpp \
+    ../include/mapnik/text_placements/simple.hpp \
+    ../include/mapnik/util/container_adapter.hpp \
     ../include/mapnik/util/conversions.hpp \
+    ../include/mapnik/util/dasharray_parser.hpp \
+    ../include/mapnik/util/deepcopy.hpp \
+    ../include/mapnik/util/geometry_svg_generator.hpp \
+    ../include/mapnik/util/geometry_to_ds_type.hpp \
+    ../include/mapnik/util/geometry_to_wkb.hpp \
+    ../include/mapnik/util/geometry_to_wkt.hpp \
+    ../include/mapnik/util/geometry_wkt_generator.hpp \
+    ../include/mapnik/util/vertex_iterator.hpp \
     ../include/mapnik/wkt/wkt_factory.hpp \
     ../include/mapnik/wkt/wkt_grammar.hpp \
+    ../include/mapnik/agg_helpers.hpp \
     ../include/mapnik/agg_pattern_source.hpp \
     ../include/mapnik/agg_rasterizer.hpp \
     ../include/mapnik/agg_renderer.hpp \
     ../include/mapnik/arrow.hpp \
+    ../include/mapnik/attribute.hpp \
     ../include/mapnik/attribute_collector.hpp \
     ../include/mapnik/attribute_descriptor.hpp \
-    ../include/mapnik/attribute.hpp \
-    ../include/mapnik/box2d.hpp \
     ../include/mapnik/boolean.hpp \
+    ../include/mapnik/box2d.hpp \
+    ../include/mapnik/building_symbolizer.hpp \
     ../include/mapnik/cairo_renderer.hpp \
-    ../include/mapnik/color_factory.hpp \
+    ../include/mapnik/char_info.hpp \
     ../include/mapnik/color.hpp \
-    ../include/mapnik/config_error.hpp \
+    ../include/mapnik/color_factory.hpp \
     ../include/mapnik/config.hpp \
-    ../include/mapnik/coord_array.hpp \
+    ../include/mapnik/config_error.hpp \
     ../include/mapnik/coord.hpp \
-    ../include/mapnik/css_color_grammar_deprecated.hpp \
+    ../include/mapnik/coord_array.hpp \
     ../include/mapnik/css_color_grammar.hpp \
+    ../include/mapnik/css_color_grammar_deprecated.hpp \
     ../include/mapnik/ctrans.hpp \
-    ../include/mapnik/datasource_cache.hpp \
+    ../include/mapnik/debug.hpp \
     ../include/mapnik/datasource.hpp \
+    ../include/mapnik/datasource_cache.hpp \
     ../include/mapnik/distance.hpp \
     ../include/mapnik/ellipsoid.hpp \
     ../include/mapnik/enumeration.hpp \
@@ -68,19 +99,19 @@ HEADERS += \
     ../include/mapnik/expression_string.hpp \
     ../include/mapnik/factory.hpp \
     ../include/mapnik/fastmath.hpp \
-    ../include/mapnik/feature_factory.hpp \
     ../include/mapnik/feature.hpp \
+    ../include/mapnik/feature_factory.hpp \
+    ../include/mapnik/feature_kv_iterator.hpp \
     ../include/mapnik/feature_layer_desc.hpp \
     ../include/mapnik/feature_style_processor.hpp \
     ../include/mapnik/feature_type_style.hpp \
-    ../include/mapnik/fill.hpp \
     ../include/mapnik/filter_factory.hpp \
     ../include/mapnik/filter_featureset.hpp \
     ../include/mapnik/font_engine_freetype.hpp \
     ../include/mapnik/font_set.hpp \
-    ../include/mapnik/gamma.hpp \
-    ../include/mapnik/geometry.hpp \
+    ../include/mapnik/gamma_method.hpp \
     ../include/mapnik/geom_util.hpp \
+    ../include/mapnik/geometry.hpp \
     ../include/mapnik/global.hpp \
     ../include/mapnik/gradient.hpp \
     ../include/mapnik/graphics.hpp \
@@ -94,21 +125,20 @@ HEADERS += \
     ../include/mapnik/jpeg_io.hpp \
     ../include/mapnik/label_collision_detector.hpp \
     ../include/mapnik/layer.hpp \
-    ../include/mapnik/libxml2_loader.hpp \
     ../include/mapnik/line_pattern_symbolizer.hpp \
     ../include/mapnik/line_symbolizer.hpp \
     ../include/mapnik/load_map.hpp \
     ../include/mapnik/map.hpp \
     ../include/mapnik/mapped_memory_cache.hpp \
-    ../include/mapnik/marker_cache.hpp \
     ../include/mapnik/marker.hpp \
+    ../include/mapnik/marker_cache.hpp \
     ../include/mapnik/markers_placement.hpp \
     ../include/mapnik/markers_symbolizer.hpp \
+    ../include/mapnik/memory.hpp \
     ../include/mapnik/memory_datasource.hpp \
     ../include/mapnik/memory_featureset.hpp \
-    ../include/mapnik/memory.hpp \
-    ../include/mapnik/metawriter_factory.hpp \
     ../include/mapnik/metawriter.hpp \
+    ../include/mapnik/metawriter_factory.hpp \
     ../include/mapnik/metawriter_inmem.hpp \
     ../include/mapnik/metawriter_json.hpp \
     ../include/mapnik/octree.hpp \
@@ -116,6 +146,7 @@ HEADERS += \
     ../include/mapnik/params.hpp \
     ../include/mapnik/parse_path.hpp \
     ../include/mapnik/path_expression_grammar.hpp \
+    ../include/mapnik/pixel_position.hpp \
     ../include/mapnik/placement_finder.hpp \
     ../include/mapnik/plugin.hpp \
     ../include/mapnik/png_io.hpp \
@@ -123,13 +154,14 @@ HEADERS += \
     ../include/mapnik/polygon_pattern_symbolizer.hpp \
     ../include/mapnik/polygon_symbolizer.hpp \
     ../include/mapnik/pool.hpp \
-    ../include/mapnik/projection.hpp \
+    ../include/mapnik/processed_text.hpp \
     ../include/mapnik/proj_transform.hpp \
+    ../include/mapnik/projection.hpp \
     ../include/mapnik/ptree_helpers.hpp \
     ../include/mapnik/quad_tree.hpp \
     ../include/mapnik/query.hpp \
-    ../include/mapnik/raster_colorizer.hpp \
     ../include/mapnik/raster.hpp \
+    ../include/mapnik/raster_colorizer.hpp \
     ../include/mapnik/raster_symbolizer.hpp \
     ../include/mapnik/rule.hpp \
     ../include/mapnik/save_map.hpp \
@@ -138,25 +170,26 @@ HEADERS += \
     ../include/mapnik/shield_symbolizer.hpp \
     ../include/mapnik/sql_utils.hpp \
     ../include/mapnik/stroke.hpp \
-    ../include/mapnik/style_factory.hpp \
     ../include/mapnik/svg_renderer.hpp \
     ../include/mapnik/symbolizer.hpp \
+    ../include/mapnik/symbolizer_helpers.hpp \
     ../include/mapnik/text_path.hpp \
-    ../include/mapnik/text_placements.hpp \
-    ../include/mapnik/text_placements_simple.hpp \
+    ../include/mapnik/text_properties.hpp \
     ../include/mapnik/text_symbolizer.hpp \
     ../include/mapnik/tiff_io.hpp \
     ../include/mapnik/timer.hpp \
     ../include/mapnik/unicode.hpp \
     ../include/mapnik/utils.hpp \
-    ../include/mapnik/value_error.hpp \
     ../include/mapnik/value.hpp \
+    ../include/mapnik/value_error.hpp \
     ../include/mapnik/version.hpp \
     ../include/mapnik/vertex.hpp \
-    ../include/mapnik/vertex_transform.hpp \
     ../include/mapnik/vertex_vector.hpp \
     ../include/mapnik/warp.hpp \
-    ../include/mapnik/wkb.hpp
+    ../include/mapnik/wkb.hpp \
+    ../include/mapnik/xml_loader.hpp \
+    ../include/mapnik/xml_node.hpp \
+    ../include/mapnik/xml_tree.hpp
 
 
 SOURCES += \
@@ -166,49 +199,71 @@ SOURCES += \
     ../src/agg/process_line_symbolizer.cpp \
     ../src/agg/process_markers_symbolizer.cpp \
     ../src/agg/process_point_symbolizer.cpp \
-    ../src/agg/process_polygon_symbolizer.cpp \
     ../src/agg/process_polygon_pattern_symbolizer.cpp \
+    ../src/agg/process_polygon_symbolizer.cpp \
     ../src/agg/process_raster_symbolizer.cpp \
     ../src/agg/process_shield_symbolizer.cpp \
     ../src/agg/process_text_symbolizer.cpp \
+    ../src/formatting/base.cpp \
+    ../src/formatting/expression.cpp \
+    ../src/formatting/format.cpp \
+    ../src/formatting/list.cpp \
+    ../src/formatting/registry.cpp \
+    ../src/formatting/text.cpp \
     ../src/grid/grid_renderer.cpp \
     ../src/grid/process_building_symbolizer.cpp \
     ../src/grid/process_line_pattern_symbolizer.cpp \
     ../src/grid/process_line_symbolizer.cpp \
     ../src/grid/process_markers_symbolizer.cpp \
     ../src/grid/process_point_symbolizer.cpp \
+    ../src/grid/process_polygon_pattern_symbolizer.cpp \
     ../src/grid/process_polygon_symbolizer.cpp \
     ../src/grid/process_raster_symbolizer.cpp \
     ../src/grid/process_shield_symbolizer.cpp \
     ../src/grid/process_text_symbolizer.cpp \
-    ../src/svg/svg_renderer.cpp \
-    ../src/svg/svg_generator.cpp \
-    ../src/svg/svg_output_attributes.cpp \
-    ../src/svg/process_symbolizers.cpp \
+    ../src/json/feature_collection_parser.cpp \
+    ../src/json/geojson_generator.cpp \
     ../src/svg/process_building_symbolizer.cpp \
     ../src/svg/process_line_pattern_symbolizer.cpp \
     ../src/svg/process_line_symbolizer.cpp \
     ../src/svg/process_markers_symbolizer.cpp \
     ../src/svg/process_point_symbolizer.cpp \
+    ../src/svg/process_polygon_pattern_symbolizer.cpp \
     ../src/svg/process_polygon_symbolizer.cpp \
     ../src/svg/process_raster_symbolizer.cpp \
     ../src/svg/process_shield_symbolizer.cpp \
+    ../src/svg/process_symbolizers.cpp \
     ../src/svg/process_text_symbolizer.cpp \
+    ../src/svg/svg_generator.cpp \
+    ../src/svg/svg_output_attributes.cpp \
+    ../src/svg/svg_renderer.cpp \
+    ../src/text_placements/base.cpp \
+    ../src/text_placements/dummy.cpp \
+    ../src/text_placements/list.cpp \
+    ../src/text_placements/registry.cpp \
+    ../src/text_placements/simple.cpp \
     ../src/wkt/wkt_factory.cpp \
     ../src/arrow.cpp \
     ../src/box2d.cpp \
+    ../src/building_symbolizer.cpp \
     ../src/cairo_renderer.cpp \
     ../src/color.cpp \
+    ../src/config_error.cpp \
+    ../src/conversions.cpp \
     ../src/datasource_cache.cpp \
+    ../src/deepcopy.cpp \
     ../src/distance.cpp \
+    ../src/expression.cpp \
     ../src/expression_string.cpp \
+    ../src/feature_kv_iterator.cpp \
     ../src/feature_style_processor.cpp \
     ../src/feature_type_style.cpp \
-    ../src/filter_factory.cpp \
     ../src/font_engine_freetype.cpp \
     ../src/font_set.cpp \
+    ../src/gamma_method.cpp \
     ../src/gradient.cpp \
     ../src/graphics.cpp \
+    ../src/image_compositing.cpp \
     ../src/image_reader.cpp \
     ../src/image_util.cpp \
     ../src/jpeg_reader.cpp \
@@ -220,6 +275,7 @@ SOURCES += \
     ../src/map.cpp \
     ../src/mapped_memory_cache.cpp \
     ../src/marker_cache.cpp \
+    ../src/markers_placement.cpp \
     ../src/markers_symbolizer.cpp \
     ../src/memory.cpp \
     ../src/memory_datasource.cpp \
@@ -233,8 +289,11 @@ SOURCES += \
     ../src/png_reader.cpp \
     ../src/point_symbolizer.cpp \
     ../src/polygon_pattern_symbolizer.cpp \
-    ../src/projection.cpp \
+    ../src/polygon_symbolizer.cpp \
+    ../src/processed_text.cpp \
     ../src/proj_transform.cpp \
+    ../src/projection.cpp \
+    ../src/rapidxml_loader.cpp \
     ../src/raster_colorizer.cpp \
     ../src/save_map.cpp \
     ../src/scale_denominator.cpp \
@@ -245,12 +304,14 @@ SOURCES += \
     ../src/svg_points_parser.cpp \
     ../src/svg_transform_parser.cpp \
     ../src/symbolizer.cpp \
-    ../src/text_placements.cpp \
+    ../src/symbolizer_helpers.cpp \
+    ../src/text_properties.cpp \
     ../src/text_symbolizer.cpp \
     ../src/tiff_reader.cpp \
     ../src/unicode.cpp \
     ../src/warp.cpp \
-    ../src/wkb.cpp
+    ../src/wkb.cpp \
+    ../src/xml_tree.cpp
 
 OTHER_FILES += \
     ../SConstruct \
diff --git a/workspace/plugins.pri b/workspace/plugins.pri
index 0f52001e8..08ee6bc00 100644
--- a/workspace/plugins.pri
+++ b/workspace/plugins.pri
@@ -47,6 +47,7 @@ HEADERS += \
   $$PWD/../plugins/input/shape/shape_index_featureset.hpp \
   $$PWD/../plugins/input/shape/shape_io.hpp \
   $$PWD/../plugins/input/shape/shp_index.hpp \
+  $$PWD/../plugins/input/sqlite/sqlite_connection.hpp \
   $$PWD/../plugins/input/sqlite/sqlite_featureset.hpp \
   $$PWD/../plugins/input/sqlite/sqlite_datasource.hpp \
   $$PWD/../plugins/input/sqlite/sqlite_types.hpp
@@ -67,7 +68,7 @@ SOURCES += \
   $$PWD/../plugins/input/ogr/ogr_converter.cpp \
   $$PWD/../plugins/input/ogr/ogr_featureset.cpp \
   $$PWD/../plugins/input/ogr/ogr_datasource.cpp \
-  $$PWD/../plugins/input/ogr/ogr_index_featureset.hpp \
+  $$PWD/../plugins/input/ogr/ogr_index_featureset.cpp \
   $$PWD/../plugins/input/osm/basiccurl.cpp \
   $$PWD/../plugins/input/osm/dataset_deliverer.cpp \
   $$PWD/../plugins/input/osm/osm.cpp \