Use prefixed log macros

Author: eoger

components/places/examples/autocomplete.rs

@@ -4,7 +4,6 @@
 
 use clap::value_t;
 use failure::bail;
-use log::*;
 use places::{VisitObservation, VisitTransition};
 use serde_derive::*;
 use sql_support::ConnExt;
@@ -157,7 +156,7 @@ fn import_places(
         (ps, vs)
     };
 
-    info!(
+    log::info!(
         "Importing {} visits across {} places!",
         place_count, visit_count
     );
@@ -231,7 +230,7 @@ fn import_places(
     println!("Finished processing records");
     println!("Committing....");
     tx.commit()?;
-    info!("Finished import!");
+    log::info!("Finished import!");
     Ok(())
 }
 
@@ -345,7 +344,7 @@ mod autocomplete {
                             }
                             Err(e) => {
                                 // TODO: this is likely not to go very well since we're in raw mode...
-                                error!("Got error doing autocomplete: {:?}", e);
+                                log::error!("Got error doing autocomplete: {:?}", e);
                                 panic!("Got error doing autocomplete: {:?}", e);
                                 // return Err(e.into());
                             }
@@ -808,14 +807,14 @@ fn main() -> Result<()> {
                 .unwrap_or(0.1),
         };
         let import_source = if import_places_arg == "auto" {
-            info!("Automatically locating largest places DB in your profile(s)");
+            log::info!("Automatically locating largest places DB in your profile(s)");
             let profile_info = if let Some(info) = find_places_db::get_largest_places_db()? {
                 info
             } else {
-                error!("Failed to locate your firefox profile!");
+                log::error!("Failed to locate your firefox profile!");
                 bail!("--import-places=auto specified, but couldn't find a `places.sqlite`");
             };
-            info!(
+            log::info!(
                 "Using a {} places.sqlite from profile '{}' (places path = {:?})",
                 profile_info.friendly_db_size(),
                 profile_info.profile_name,
@@ -848,17 +847,17 @@ fn main() -> Result<()> {
     }
 
     if let Some(observations_json) = matches.value_of("import_observations") {
-        info!("Importing observations from {}", observations_json);
+        log::info!("Importing observations from {}", observations_json);
         let observations: Vec<SerializedObservation> = read_json_file(observations_json)?;
         let num_observations = observations.len();
-        info!("Found {} observations", num_observations);
+        log::info!("Found {} observations", num_observations);
         let mut counter = 0;
         for obs in observations {
             let visit = obs.into_visit()?;
             places::apply_observation(&mut conn, visit)?;
             counter += 1;
             if (counter % 1000) == 0 {
-                trace!("Importing observations {} / {}", counter, num_observations);
+                log::trace!("Importing observations {} / {}", counter, num_observations);
             }
         }
     }

components/places/examples/sync_history.rs

@@ -4,7 +4,6 @@
 
 use failure::Fail;
 use fxa_client::{AccessTokenInfo, Config, FirefoxAccount};
-use log::*;
 use places::history_sync::store::HistoryStore;
 use places::PlacesDb;
 use std::{fs, io::Read};
@@ -87,7 +86,7 @@ fn main() -> Result<()> {
         .expect("Encryption key is not optional");
 
     // Lets not log the encryption key, it's just not a good habit to be in.
-    debug!(
+    log::debug!(
         "Using credential file = {:?}, db = {:?}",
         cred_file, db_path
     );
@@ -117,22 +116,22 @@ fn main() -> Result<()> {
     let store = HistoryStore::new(&db);
 
     if matches.is_present("wipe-remote") {
-        info!("Wiping remote");
+        log::info!("Wiping remote");
         let client = Sync15StorageClient::new(client_init.clone())?;
         client.wipe_all_remote()?;
     }
 
     if matches.is_present("reset") {
-        info!("Resetting");
+        log::info!("Resetting");
         store.reset()?;
     }
 
-    info!("Syncing!");
+    log::info!("Syncing!");
     if let Err(e) = store.sync(&client_init, &root_sync_key) {
-        warn!("Sync failed! {}", e);
-        warn!("BT: {:?}", e.backtrace());
+        log::warn!("Sync failed! {}", e);
+        log::warn!("BT: {:?}", e.backtrace());
     } else {
-        info!("Sync was successful!");
+        log::info!("Sync was successful!");
     }
     println!("Exiting (bye!)");
     Ok(())

components/places/ffi/src/lib.rs

@@ -6,7 +6,6 @@ use ffi_support::{
     call_with_result, define_box_destructor, define_string_destructor, rust_str_from_c,
     rust_string_from_c, ExternError,
 };
-use log::*;
 use places::history_sync::store::HistoryStore;
 use places::{storage, PlacesDb};
 use std::os::raw::c_char;
@@ -25,7 +24,7 @@ fn logging_init() {
             android_logger::Filter::default().with_min_level(log::Level::Trace),
             Some("libplaces_ffi"),
         );
-        debug!("Android logging should be hooked up!")
+        log::debug!("Android logging should be hooked up!")
     }
 }
 
@@ -40,7 +39,7 @@ pub unsafe extern "C" fn places_connection_new(
     encryption_key: *const c_char,
     error: &mut ExternError,
 ) -> *mut PlacesDb {
-    trace!("places_connection_new");
+    log::trace!("places_connection_new");
     logging_init();
     call_with_result(error, || {
         let path = ffi_support::rust_string_from_c(db_path);
@@ -57,7 +56,7 @@ pub unsafe extern "C" fn places_note_observation(
     json_observation: *const c_char,
     error: &mut ExternError,
 ) {
-    trace!("places_note_observation");
+    log::trace!("places_note_observation");
     call_with_result(error, || {
         let json = ffi_support::rust_str_from_c(json_observation);
         let visit: places::VisitObservation = serde_json::from_str(&json)?;
@@ -74,7 +73,7 @@ pub unsafe extern "C" fn places_query_autocomplete(
     limit: u32,
     error: &mut ExternError,
 ) -> *mut c_char {
-    trace!("places_query_autocomplete");
+    log::trace!("places_query_autocomplete");
     call_with_result(error, || {
         search_frecent(
             conn,
@@ -92,7 +91,7 @@ pub unsafe extern "C" fn places_get_visited(
     urls_json: *const c_char,
     error: &mut ExternError,
 ) -> *mut c_char {
-    trace!("places_get_visited");
+    log::trace!("places_get_visited");
     // This function has a dumb amount of overhead and copying...
     call_with_result(error, || -> places::Result<String> {
         let json = ffi_support::rust_str_from_c(urls_json);
@@ -116,7 +115,7 @@ pub extern "C" fn places_get_visited_urls_in_range(
     include_remote: u8, // JNA has issues with bools...
     error: &mut ExternError,
 ) -> *mut c_char {
-    trace!("places_get_visited_in_range");
+    log::trace!("places_get_visited_in_range");
     call_with_result(error, || -> places::Result<String> {
         let visited = storage::get_visited_urls(
             conn,
@@ -138,7 +137,7 @@ pub unsafe extern "C" fn sync15_history_sync(
     tokenserver_url: *const c_char,
     error: &mut ExternError,
 ) {
-    trace!("sync15_history_sync");
+    log::trace!("sync15_history_sync");
     call_with_result(error, || -> places::Result<()> {
         // XXX - this is wrong - we kinda want this to be long-lived - the "Db"
         // should own the store, but it's not part of the db.

components/places/src/api/history.rs

@@ -7,7 +7,6 @@ use crate::db::PlacesDb;
 use crate::error::*;
 use crate::observation::VisitObservation;
 use crate::types::*;
-use log::*;
 use url::Url;
 
 // This module can become, roughly: PlacesUtils.history()
@@ -182,7 +181,7 @@ pub fn visit_uri(
     // EMBED visits are session-persistent and should not go through the database.
     // They exist only to keep track of isVisited status during the session.
     if transition == VisitTransition::Embed {
-        warn!("Embed visit, but in-memory storage of these isn't done yet");
+        log::warn!("Embed visit, but in-memory storage of these isn't done yet");
         return Ok(());
     }
 

components/places/src/db/schema.rs

@@ -10,7 +10,6 @@
 use crate::db::PlacesDb;
 use crate::error::*;
 use lazy_static::lazy_static;
-use log::*;
 use sql_support::ConnExt;
 
 const VERSION: i64 = 2;
@@ -236,7 +235,7 @@ pub fn init(db: &PlacesDb) -> Result<()> {
         if user_version < VERSION {
             upgrade(db, user_version)?;
         } else {
-            warn!(
+            log::warn!(
                 "Loaded future schema version {} (we only understand version {}). \
                  Optimisitically ",
                 user_version, VERSION
@@ -248,7 +247,7 @@ pub fn init(db: &PlacesDb) -> Result<()> {
 
 // https://github.com/mozilla-mobile/firefox-ios/blob/master/Storage/SQL/LoginsSchema.swift#L100
 fn upgrade(_db: &PlacesDb, from: i64) -> Result<()> {
-    debug!("Upgrading schema from {} to {}", from, VERSION);
+    log::debug!("Upgrading schema from {} to {}", from, VERSION);
     if from == VERSION {
         return Ok(());
     }
@@ -258,7 +257,7 @@ fn upgrade(_db: &PlacesDb, from: i64) -> Result<()> {
 }
 
 pub fn create(db: &PlacesDb) -> Result<()> {
-    debug!("Creating schema");
+    log::debug!("Creating schema");
     db.execute_all(&[
         CREATE_TABLE_PLACES_SQL,
         CREATE_TABLE_PLACES_TOMBSTONES_SQL,
@@ -283,7 +282,7 @@ pub fn create(db: &PlacesDb) -> Result<()> {
         &format!("PRAGMA user_version = {version}", version = VERSION),
     ])?;
 
-    debug!("Creating temp tables and triggers");
+    log::debug!("Creating temp tables and triggers");
     db.execute_all(&[
         CREATE_TRIGGER_AFTER_INSERT_ON_PLACES,
         &CREATE_TRIGGER_HISTORYVISITS_AFTERINSERT,

components/places/src/ffi.rs

@@ -12,7 +12,6 @@ use crate::error::{Error, ErrorKind};
 use ffi_support::{
     implement_into_ffi_by_json, implement_into_ffi_by_pointer, ErrorCode, ExternError,
 };
-use log::*;
 
 pub mod error_codes {
     // Note: 0 (success) and -1 (panic) are reserved by ffi_support
@@ -36,23 +35,23 @@ pub mod error_codes {
 fn get_code(err: &Error) -> ErrorCode {
     match err.kind() {
         ErrorKind::InvalidPlaceInfo(info) => {
-            error!("Invalid place info: {}", info);
+            log::error!("Invalid place info: {}", info);
             ErrorCode::new(error_codes::INVALID_PLACE_INFO)
         }
         ErrorKind::UrlParseError(e) => {
-            error!("URL parse error: {}", e);
+            log::error!("URL parse error: {}", e);
             ErrorCode::new(error_codes::URL_PARSE_ERROR)
         }
         // Can't pattern match on `err` without adding a dep on the sqlite3-sys crate,
         // so we just use a `if` guard.
         ErrorKind::SqlError(rusqlite::Error::SqliteFailure(err, msg))
             if err.code == rusqlite::ErrorCode::DatabaseBusy =>
         {
-            error!("Database busy: {:?} {:?}", err, msg);
+            log::error!("Database busy: {:?} {:?}", err, msg);
             ErrorCode::new(error_codes::DATABASE_BUSY)
         }
         err => {
-            error!("Unexpected error: {:?}", err);
+            log::error!("Unexpected error: {:?}", err);
             ErrorCode::new(error_codes::UNEXPECTED)
         }
     }

components/places/src/history_sync/plan.rs

@@ -12,7 +12,6 @@ use crate::storage::history_sync::{
 };
 use crate::types::{SyncGuid, Timestamp, VisitTransition};
 use crate::valid_guid::is_valid_places_guid;
-use log::*;
 use rusqlite::Connection;
 use sql_support::ConnExt;
 use std::collections::HashSet;
@@ -184,7 +183,7 @@ pub fn apply_plan(conn: &Connection, inbound: IncomingChangeset) -> Result<Outgo
             Err(e) => {
                 // We can't push IncomingPlan::Invalid into plans as we don't
                 // know the guid - just skip it.
-                warn!("Error deserializing incoming record: {}", e);
+                log::warn!("Error deserializing incoming record: {}", e);
                 continue;
             }
         };
@@ -205,19 +204,19 @@ pub fn apply_plan(conn: &Connection, inbound: IncomingChangeset) -> Result<Outgo
     for (guid, plan) in plans {
         match &plan {
             IncomingPlan::Skip => {
-                trace!("incoming: skipping item {:?}", guid);
+                log::trace!("incoming: skipping item {:?}", guid);
             }
             IncomingPlan::Invalid(err) => {
-                warn!(
+                log::warn!(
                     "incoming: record {:?} skipped because it is invalid: {}",
                     guid, err
                 );
             }
             IncomingPlan::Failed(err) => {
-                error!("incoming: record {:?} failed to apply: {}", guid, err);
+                log::error!("incoming: record {:?} failed to apply: {}", guid, err);
             }
             IncomingPlan::Delete => {
-                trace!("incoming: deleting {:?}", guid);
+                log::trace!("incoming: deleting {:?}", guid);
                 num_deleted += 1;
                 apply_synced_deletion(&conn, &guid)?;
             }
@@ -228,7 +227,7 @@ pub fn apply_plan(conn: &Connection, inbound: IncomingChangeset) -> Result<Outgo
                 visits,
             } => {
                 num_applied += 1;
-                trace!(
+                log::trace!(
                     "incoming: will apply {:?}: url={:?}, title={:?}, to_add={:?}",
                     guid,
                     url,
@@ -249,7 +248,7 @@ pub fn apply_plan(conn: &Connection, inbound: IncomingChangeset) -> Result<Outgo
             }
             IncomingPlan::Reconciled => {
                 num_reconciled += 1;
-                trace!("incoming: reconciled {:?}", guid);
+                log::trace!("incoming: reconciled {:?}", guid);
                 apply_synced_reconciliation(&conn, &guid)?;
             }
         };
@@ -263,12 +262,12 @@ pub fn apply_plan(conn: &Connection, inbound: IncomingChangeset) -> Result<Outgo
             OutgoingInfo::Record(record) => Payload::from_record(record)?,
             OutgoingInfo::Tombstone => Payload::new_tombstone_with_ttl(guid.0.clone(), HISTORY_TTL),
         };
-        trace!("outgoing {:?}", payload);
+        log::trace!("outgoing {:?}", payload);
         outgoing.changes.push(payload);
     }
     tx.commit()?;
 
-    info!(
+    log::info!(
         "incoming: applied {}, deleted {}, reconciled {}",
         num_applied, num_deleted, num_reconciled
     );
@@ -279,7 +278,7 @@ pub fn apply_plan(conn: &Connection, inbound: IncomingChangeset) -> Result<Outgo
 pub fn finish_plan(conn: &Connection) -> Result<()> {
     let tx = conn.unchecked_transaction()?;
     finish_outgoing(conn)?;
-    trace!("Committing final sync plan");
+    log::trace!("Committing final sync plan");
     tx.commit()?;
     Ok(())
 }