Sort out log levels of all log messages

Going through all log messages and sort them into better and more
consistent log levels.

Author: joto

src/expire-tiles.cpp

@@ -32,9 +32,9 @@ tile_output_t::tile_output_t(char const *filename)
 : outfile(fopen(filename, "a"))
 {
     if (outfile == nullptr) {
-        log_error("Failed to open expired tiles file ({}).  Tile expiry "
-                  "list will not be written!",
-                  std::strerror(errno));
+        log_warn("Failed to open expired tiles file ({}).  Tile expiry "
+                 "list will not be written!",
+                 std::strerror(errno));
     }
 }
 
@@ -354,9 +354,9 @@ void expire_tiles::from_wkb_polygon(ewkb::parser_t *wkb, osmid_t osm_id)
 
     if (from_bbox(min.x, min.y, max.x, max.y)) {
         /* Bounding box too big - just expire tiles on the line */
-        log_info("Large polygon ({:.0f} x {:.0f} metres, OSM ID {})"
-                 " - only expiring perimeter",
-                 max.x - min.x, max.y - min.y, osm_id);
+        log_debug("Large polygon ({:.0f} x {:.0f} metres, OSM ID {})"
+                  " - only expiring perimeter",
+                  max.x - min.x, max.y - min.y, osm_id);
         wkb->rewind(start);
         for (unsigned ring = 0; ring < num_rings; ++ring) {
             from_wkb_line(wkb);

src/flex-table.cpp

@@ -210,7 +210,7 @@ void table_connection_t::stop(bool updateable, bool append)
 
         sql += " ORDER BY ";
         if (postgis_version.major == 2 && postgis_version.minor < 4) {
-            log_info("Using GeoHash for clustering");
+            log_debug("Using GeoHash for clustering");
             if (table().geom_column().srid() == 4326) {
                 sql += "ST_GeoHash({},10)"_format(table().geom_column().name());
             } else {
@@ -220,7 +220,7 @@ void table_connection_t::stop(bool updateable, bool append)
             }
             sql += " COLLATE \"C\"";
         } else {
-            log_info("Using native order for clustering");
+            log_debug("Using native order for clustering");
             // Since Postgis 2.4 the order function for geometries gives
             // useful results.
             sql += table().geom_column().name();
@@ -273,7 +273,7 @@ void table_connection_t::prepare()
 void table_connection_t::create_id_index()
 {
     if (m_id_index_created) {
-        log_info("Id index on table '{}' already created.", table().name());
+        log_debug("Id index on table '{}' already created.", table().name());
     } else {
         log_info("Creating id index on table '{}'...", table().name());
         m_db_connection->exec(table().build_sql_create_id_index());

src/middle-pgsql.cpp

@@ -88,14 +88,14 @@ void middle_query_pgsql_t::exec_sql(std::string const &sql_cmd) const
 void middle_pgsql_t::table_desc::stop(std::string const &conninfo,
                                       bool droptemp, bool build_indexes)
 {
-    log_info("Stopping table: {}", name());
     util::timer_t timer;
 
     // Use a temporary connection here because we might run in a separate
     // thread context.
     pg_conn_t sql_conn{conninfo};
 
     if (droptemp) {
+        log_info("Dropping table: {}", name());
         auto const qual_name = qualified_name(
             m_copy_target->schema, m_copy_target->name);
         sql_conn.exec("DROP TABLE IF EXISTS {}"_format(qual_name));
@@ -104,7 +104,7 @@ void middle_pgsql_t::table_desc::stop(std::string const &conninfo,
         sql_conn.exec(m_create_fw_dep_indexes);
     }
 
-    log_info("Stopped table: {} in {}", name(),
+    log_info("Done postprocessing table: {} in {}", name(),
              util::human_readable_duration(timer.stop()));
 }
 
@@ -575,7 +575,7 @@ void middle_pgsql_t::start()
         // (Re)create tables.
         m_db_connection.exec("SET client_min_messages = WARNING");
         for (auto const &table : m_tables) {
-            log_info("Setting up table: {}", table.name());
+            log_debug("Setting up table: {}", table.name());
             auto const qual_name = qualified_name(
                 table.m_copy_target->schema, table.m_copy_target->name);
             m_db_connection.exec(
@@ -755,7 +755,7 @@ middle_pgsql_t::middle_pgsql_t(options_t const *options)
         m_persistent_cache.reset(new node_persistent_cache{options, m_cache});
     }
 
-    log_info("Mid: pgsql, cache={}", options->cache);
+    log_debug("Mid: pgsql, cache={}", options->cache);
 
     bool const has_bucket_index =
         check_bucket_index(&m_db_connection, options->prefix);

src/node-persistent-cache.cpp

@@ -52,7 +52,7 @@ node_persistent_cache::node_persistent_cache(
 
     m_fname = options->flat_node_file->c_str();
     m_remove_file = options->droptemp;
-    log_info("Mid: loading persistent node cache from {}", m_fname);
+    log_debug("Mid: loading persistent node cache from {}", m_fname);
 
     // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg, hicpp-signed-bitwise)
     m_fd = open(m_fname, O_RDWR | O_CREAT, 0644);
@@ -74,7 +74,7 @@ node_persistent_cache::~node_persistent_cache() noexcept
 
     if (m_remove_file) {
         try {
-            log_info("Mid: removing persistent node cache at {}", m_fname);
+            log_debug("Mid: removing persistent node cache at {}", m_fname);
         } catch (...) {
         }
         unlink(m_fname);

src/node-ram-cache.cpp

@@ -306,7 +306,7 @@ node_ram_cache::node_ram_cache(int strategy, int cacheSizeMB)
     maxSparseTuples = (cacheSize / sizeof(ramNodeID)) + 1;
 
     if ((allocStrategy & ALLOC_DENSE) > 0) {
-        log_info("Allocating memory for dense node cache");
+        log_debug("Allocating memory for dense node cache");
         blocks = (ramNodeBlock *)calloc(num_blocks(), sizeof(ramNodeBlock));
         if (!blocks) {
             throw std::runtime_error{
@@ -319,12 +319,12 @@ node_ram_cache::node_ram_cache(int strategy, int cacheSizeMB)
          * once it is needed.
          */
         if ((allocStrategy & ALLOC_DENSE_CHUNK) > 0) {
-            log_info("Allocating dense node cache in block sized chunks");
+            log_debug("Allocating dense node cache in block sized chunks");
             if (!queue) {
                 throw std::runtime_error{"Out of memory, reduce --cache size."};
             }
         } else {
-            log_info("Allocating dense node cache in one big chunk");
+            log_debug("Allocating dense node cache in one big chunk");
             blockCache = (char *)malloc((maxBlocks + 1024) * per_block() *
                                         sizeof(osmium::Location));
             if (!queue || !blockCache) {
@@ -343,12 +343,12 @@ node_ram_cache::node_ram_cache(int strategy, int cacheSizeMB)
      */
 
     if ((allocStrategy & ALLOC_SPARSE) > 0) {
-        log_info("Allocating memory for sparse node cache");
+        log_debug("Allocating memory for sparse node cache");
         if (!blockCache) {
             sparseBlock =
                 (ramNodeID *)malloc(maxSparseTuples * sizeof(ramNodeID));
         } else {
-            log_info("Sharing dense sparse");
+            log_debug("Sharing dense sparse");
             sparseBlock = (ramNodeID *)blockCache;
         }
         if (!sparseBlock) {

src/options.cpp

@@ -357,7 +357,7 @@ static osmium::Box parse_bbox(char const *bbox)
             "Bounding box failed due to maxlat <= minlat."};
     }
 
-    log_info("Applying bounding box: {},{} to {},{}", minx, miny, maxx, maxy);
+    log_debug("Applying bounding box: {},{} to {},{}", minx, miny, maxx, maxy);
 
     return osmium::Box{minx, miny, maxx, maxy};
 }

src/osm2pgsql.cpp

@@ -75,7 +75,7 @@ prepare_input_files(options_t const &options)
                 "Reading an OSM change file only works in append mode."};
         }
 
-        log_info("Reading file: {}", filename);
+        log_debug("Reading file: {}", filename);
 
         files.emplace_back(file);
     }

src/osmdata.cpp

@@ -470,12 +470,8 @@ class multithreaded_processor
     {
         auto const ids_queued = list.size();
 
-        if (get_logger().show_progress()) {
-            fmt::print(stderr, "\nGoing over pending {}s...\n", type);
-            fmt::print(stderr, "\t{} {}s are pending\n", ids_queued, type);
-            fmt::print(stderr, "\nUsing {} helper-processes\n",
-                       m_clones.size());
-        }
+        log_info("Going over {} pending {}s (using {} threads)"_format(
+            ids_queued, type, m_clones.size()));
 
         util::timer_t timer;
         std::vector<std::future<void>> workers;
@@ -503,16 +499,12 @@ class multithreaded_processor
         timer.stop();
 
         if (get_logger().show_progress()) {
-            fmt::print(stderr, "\rFinished processing {} {}s in {}\n\n",
-                       ids_queued, type,
-                       util::human_readable_duration(timer.elapsed()));
+            fmt::print(stderr, "\rLeft to process: 0.");
         }
 
-        if (timer.elapsed() > 0) {
-            log_info("{} pending {}s took {} at a rate of {:.2f}/s", ids_queued,
-                     type, util::human_readable_duration(timer.elapsed()),
-                     timer.per_second(ids_queued));
-        }
+        log_info("{} pending {}s took {} at a rate of {:.2f}/s", ids_queued,
+                 type, util::human_readable_duration(timer.elapsed()),
+                 timer.per_second(ids_queued));
     }
 
     /// Clones of all outputs, one vector of clones per thread.

src/output-flex.cpp

@@ -1511,7 +1511,6 @@ void output_flex_t::reprocess_marked()
     log_info("Reprocess marked ways (stage 2)...");
 
     if (!m_options.append) {
-        log_info("Creating id indexes...");
         util::timer_t timer;
 
         for (auto &table : m_table_connections) {

src/output-pgsql.cpp

@@ -344,8 +344,8 @@ output_pgsql_t::output_pgsql_t(
   buffer(32768, osmium::memory::Buffer::auto_grow::yes),
   rels_buffer(1024, osmium::memory::Buffer::auto_grow::yes)
 {
-    log_info("Using projection SRS {} ({})", o.projection->target_srs(),
-             o.projection->target_desc());
+    log_debug("Using projection SRS {} ({})", o.projection->target_srs(),
+              o.projection->target_desc());
 
     export_list exlist;