api!: make logging macros private

benches/send_events.rs

@@ -3,15 +3,15 @@ use criterion::{criterion_group, criterion_main, Criterion};
 
 use deltachat::context::Context;
 use deltachat::stock_str::StockStrings;
-use deltachat::{info, Event, EventType, Events};
+use deltachat::{Event, EventType, Events};
 use tempfile::tempdir;
 
 async fn send_events_benchmark(context: &Context) {
     let emitter = context.get_event_emitter();
     for _i in 0..1_000_000 {
-        info!(context, "interesting event...");
+        context.emit_event(EventType::Info("interesting event...".to_string()));
     }
-    info!(context, "DONE");
+    context.emit_event(EventType::Info("DONE".to_string()));
 
     loop {
         match emitter.recv().await.unwrap() {

deltachat-ffi/src/lib.rs

@@ -235,7 +235,10 @@ pub unsafe extern "C" fn dc_set_config(
                 .log_err(ctx)
                 .is_ok() as libc::c_int
         } else {
-            match config::Config::from_str(&key) {
+            match config::Config::from_str(&key)
+                .context("Invalid config key")
+                .log_err(ctx)
+            {
                 Ok(key) => ctx
                     .set_config(key, value.as_deref())
                     .await
@@ -244,10 +247,7 @@ pub unsafe extern "C" fn dc_set_config(
                     })
                     .log_err(ctx)
                     .is_ok() as libc::c_int,
-                Err(_) => {
-                    warn!(ctx, "dc_set_config(): invalid key");
-                    0
-                }
+                Err(_) => 0,
             }
         }
     })
@@ -276,7 +276,10 @@ pub unsafe extern "C" fn dc_get_config(
                 .unwrap_or_default()
                 .strdup()
         } else {
-            match config::Config::from_str(&key) {
+            match config::Config::from_str(&key)
+                .with_context(|| format!("Invalid key {:?}", &key))
+                .log_err(ctx)
+            {
                 Ok(key) => ctx
                     .get_config(key)
                     .await
@@ -285,10 +288,7 @@ pub unsafe extern "C" fn dc_get_config(
                     .unwrap_or_default()
                     .unwrap_or_default()
                     .strdup(),
-                Err(_) => {
-                    warn!(ctx, "dc_get_config(): invalid key '{}'", &key);
-                    "".strdup()
-                }
+                Err(_) => "".strdup(),
             }
         }
     })
@@ -308,18 +308,17 @@ pub unsafe extern "C" fn dc_set_stock_translation(
     let ctx = &*context;
 
     block_on(async move {
-        match StockMessage::from_u32(stock_id) {
-            Some(id) => match ctx.set_stock_translation(id, msg).await {
-                Ok(()) => 1,
-                Err(err) => {
-                    warn!(ctx, "set_stock_translation failed: {err:#}");
-                    0
-                }
-            },
-            None => {
-                warn!(ctx, "invalid stock message id {stock_id}");
-                0
-            }
+        match StockMessage::from_u32(stock_id)
+            .with_context(|| format!("Invalid stock message ID {stock_id}"))
+            .log_err(ctx)
+        {
+            Ok(id) => ctx
+                .set_stock_translation(id, msg)
+                .await
+                .context("set_stock_translation failed")
+                .log_err(ctx)
+                .is_ok() as libc::c_int,
+            Err(_) => 0,
         }
     })
 }
@@ -336,15 +335,10 @@ pub unsafe extern "C" fn dc_set_config_from_qr(
     let qr = to_string_lossy(qr);
     let ctx = &*context;
 
-    block_on(async move {
-        match qr::set_config_from_qr(ctx, &qr).await {
-            Ok(()) => 1,
-            Err(err) => {
-                error!(ctx, "Failed to create account from QR code: {err:#}");
-                0
-            }
-        }
-    })
+    block_on(qr::set_config_from_qr(ctx, &qr))
+        .context("Failed to create account from QR code")
+        .log_err(ctx)
+        .is_ok() as libc::c_int
 }
 
 #[no_mangle]
@@ -354,15 +348,13 @@ pub unsafe extern "C" fn dc_get_info(context: *const dc_context_t) -> *mut libc:
         return "".strdup();
     }
     let ctx = &*context;
-    block_on(async move {
-        match ctx.get_info().await {
-            Ok(info) => render_info(info).unwrap_or_default().strdup(),
-            Err(err) => {
-                warn!(ctx, "failed to get info: {err:#}");
-                "".strdup()
-            }
-        }
-    })
+    match block_on(ctx.get_info())
+        .context("Failed to get info")
+        .log_err(ctx)
+    {
+        Ok(info) => render_info(info).unwrap_or_default().strdup(),
+        Err(_) => "".strdup(),
+    }
 }
 
 fn render_info(
@@ -395,15 +387,13 @@ pub unsafe extern "C" fn dc_get_connectivity_html(
         return "".strdup();
     }
     let ctx = &*context;
-    block_on(async move {
-        match ctx.get_connectivity_html().await {
-            Ok(html) => html.strdup(),
-            Err(err) => {
-                error!(ctx, "Failed to get connectivity html: {err:#}");
-                "".strdup()
-            }
-        }
-    })
+    match block_on(ctx.get_connectivity_html())
+        .context("Failed to get connectivity html")
+        .log_err(ctx)
+    {
+        Ok(html) => html.strdup(),
+        Err(_) => "".strdup(),
+    }
 }
 
 #[no_mangle]
@@ -1255,22 +1245,19 @@ pub unsafe extern "C" fn dc_get_draft(context: *mut dc_context_t, chat_id: u32)
     }
     let ctx = &*context;
 
-    block_on(async move {
-        match ChatId::new(chat_id).get_draft(ctx).await {
-            Ok(Some(draft)) => {
-                let ffi_msg = MessageWrapper {
-                    context,
-                    message: draft,
-                };
-                Box::into_raw(Box::new(ffi_msg))
-            }
-            Ok(None) => ptr::null_mut(),
-            Err(err) => {
-                error!(ctx, "Failed to get draft for chat #{chat_id}: {err:#}");
-                ptr::null_mut()
-            }
+    match block_on(ChatId::new(chat_id).get_draft(ctx))
+        .with_context(|| format!("Failed to get draft for chat #{chat_id}"))
+        .unwrap_or_default()
+    {
+        Some(draft) => {
+            let ffi_msg = MessageWrapper {
+                context,
+                message: draft,
+            };
+            Box::into_raw(Box::new(ffi_msg))
         }
-    })
+        None => ptr::null_mut(),
+    }
 }
 
 #[no_mangle]
@@ -1526,10 +1513,7 @@ pub unsafe extern "C" fn dc_set_chat_visibility(
         1 => ChatVisibility::Archived,
         2 => ChatVisibility::Pinned,
         _ => {
-            warn!(
-                ctx,
-                "ignoring careless call to dc_set_chat_visibility(): unknown archived state",
-            );
+            eprintln!("ignoring careless call to dc_set_chat_visibility(): unknown archived state");
             return;
         }
     };
@@ -1683,10 +1667,11 @@ pub unsafe extern "C" fn dc_create_group_chat(
         return 0;
     }
     let ctx = &*context;
-    let protect = if let Some(s) = ProtectionStatus::from_i32(protect) {
-        s
-    } else {
-        warn!(ctx, "bad protect-value for dc_create_group_chat()");
+    let Some(protect) = ProtectionStatus::from_i32(protect)
+        .context("Bad protect-value for dc_create_group_chat()")
+        .log_err(ctx)
+        .ok()
+    else {
         return 0;
     };
 
@@ -1832,23 +1817,20 @@ pub unsafe extern "C" fn dc_set_chat_mute_duration(
         return 0;
     }
     let ctx = &*context;
-    let muteDuration = match duration {
+    let mute_duration = match duration {
         0 => MuteDuration::NotMuted,
         -1 => MuteDuration::Forever,
         n if n > 0 => SystemTime::now()
             .checked_add(Duration::from_secs(duration as u64))
             .map_or(MuteDuration::Forever, MuteDuration::Until),
         _ => {
-            warn!(
-                ctx,
-                "dc_chat_set_mute_duration(): Can not use negative duration other than -1",
-            );
+            eprintln!("dc_chat_set_mute_duration(): Can not use negative duration other than -1");
             return 0;
         }
     };
 
     block_on(async move {
-        chat::set_muted(ctx, ChatId::new(chat_id), muteDuration)
+        chat::set_muted(ctx, ChatId::new(chat_id), mute_duration)
             .await
             .map(|_| 1)
             .unwrap_or_log_default(ctx, "Failed to set mute duration")
@@ -1866,16 +1848,10 @@ pub unsafe extern "C" fn dc_get_chat_encrinfo(
     }
     let ctx = &*context;
 
-    block_on(async move {
-        ChatId::new(chat_id)
-            .get_encryption_info(ctx)
-            .await
-            .map(|s| s.strdup())
-            .unwrap_or_else(|e| {
-                error!(ctx, "{e:#}");
-                ptr::null_mut()
-            })
-    })
+    block_on(ChatId::new(chat_id).get_encryption_info(ctx))
+        .map(|s| s.strdup())
+        .log_err(ctx)
+        .unwrap_or(ptr::null_mut())
 }
 
 #[no_mangle]
@@ -2032,12 +2008,10 @@ pub unsafe extern "C" fn dc_resend_msgs(
     let ctx = &*context;
     let msg_ids = convert_and_prune_message_ids(msg_ids, msg_cnt);
 
-    if let Err(err) = block_on(chat::resend_msgs(ctx, &msg_ids)) {
-        error!(ctx, "Resending failed: {err:#}");
-        0
-    } else {
-        1
-    }
+    block_on(chat::resend_msgs(ctx, &msg_ids))
+        .context("Resending failed")
+        .log_err(ctx)
+        .is_ok() as libc::c_int
 }
 
 #[no_mangle]
@@ -2067,26 +2041,22 @@ pub unsafe extern "C" fn dc_get_msg(context: *mut dc_context_t, msg_id: u32) ->
     }
     let ctx = &*context;
 
-    block_on(async move {
-        let message = match message::Message::load_from_db(ctx, MsgId::new(msg_id)).await {
-            Ok(msg) => msg,
-            Err(e) => {
-                if msg_id <= constants::DC_MSG_ID_LAST_SPECIAL {
-                    // C-core API returns empty messages, do the same
-                    warn!(
-                        ctx,
-                        "dc_get_msg called with special msg_id={msg_id}, returning empty msg"
-                    );
-                    message::Message::new(Viewtype::default())
-                } else {
-                    warn!(ctx, "dc_get_msg could not retrieve msg_id {msg_id}: {e:#}");
-                    return ptr::null_mut();
-                }
+    let message = match block_on(message::Message::load_from_db(ctx, MsgId::new(msg_id)))
+        .with_context(|| format!("dc_get_msg could not rectieve msg_id {msg_id}"))
+        .log_err(ctx)
+    {
+        Ok(msg) => msg,
+        Err(_) => {
+            if msg_id <= constants::DC_MSG_ID_LAST_SPECIAL {
+                // C-core API returns empty messages, do the same
+                message::Message::new(Viewtype::default())
+            } else {
+                return ptr::null_mut();
             }
-        };
-        let ffi_msg = MessageWrapper { context, message };
-        Box::into_raw(Box::new(ffi_msg))
-    })
+        }
+    };
+    let ffi_msg = MessageWrapper { context, message };
+    Box::into_raw(Box::new(ffi_msg))
 }
 
 #[no_mangle]
@@ -2316,15 +2286,10 @@ pub unsafe extern "C" fn dc_get_contact_encrinfo(
     }
     let ctx = &*context;
 
-    block_on(async move {
-        Contact::get_encrinfo(ctx, ContactId::new(contact_id))
-            .await
-            .map(|s| s.strdup())
-            .unwrap_or_else(|e| {
-                error!(ctx, "{e:#}");
-                ptr::null_mut()
-            })
-    })
+    block_on(Contact::get_encrinfo(ctx, ContactId::new(contact_id)))
+        .map(|s| s.strdup())
+        .log_err(ctx)
+        .unwrap_or(ptr::null_mut())
 }
 
 #[no_mangle]
@@ -2339,15 +2304,10 @@ pub unsafe extern "C" fn dc_delete_contact(
     }
     let ctx = &*context;
 
-    block_on(async move {
-        match Contact::delete(ctx, contact_id).await {
-            Ok(_) => 1,
-            Err(err) => {
-                error!(ctx, "cannot delete contact: {err:#}");
-                0
-            }
-        }
-    })
+    block_on(Contact::delete(ctx, contact_id))
+        .context("Cannot delete contact")
+        .log_err(ctx)
+        .is_ok() as libc::c_int
 }
 
 #[no_mangle]
@@ -2418,17 +2378,13 @@ pub unsafe extern "C" fn dc_imex_has_backup(
     }
     let ctx = &*context;
 
-    block_on(async move {
-        match imex::has_backup(ctx, to_string_lossy(dir).as_ref()).await {
-            Ok(res) => res.strdup(),
-            Err(err) => {
-                // do not bubble up error to the user,
-                // the ui will expect that the file does not exist or cannot be accessed
-                warn!(ctx, "dc_imex_has_backup: {err:#}");
-                ptr::null_mut()
-            }
-        }
-    })
+    match block_on(imex::has_backup(ctx, to_string_lossy(dir).as_ref()))
+        .context("dc_imex_has_backup")
+        .log_err(ctx)
+    {
+        Ok(res) => res.strdup(),
+        Err(_) => ptr::null_mut(),
+    }
 }
 
 #[no_mangle]
@@ -2439,15 +2395,13 @@ pub unsafe extern "C" fn dc_initiate_key_transfer(context: *mut dc_context_t) ->
     }
     let ctx = &*context;
 
-    block_on(async move {
-        match imex::initiate_key_transfer(ctx).await {
-            Ok(res) => res.strdup(),
-            Err(err) => {
-                error!(ctx, "dc_initiate_key_transfer(): {err:#}");
-                ptr::null_mut()
-            }
-        }
-    })
+    match block_on(imex::initiate_key_transfer(ctx))
+        .context("dc_initiate_key_transfer()")
+        .log_err(ctx)
+    {
+        Ok(res) => res.strdup(),
+        Err(_) => ptr::null_mut(),
+    }
 }
 
 #[no_mangle]
@@ -2462,17 +2416,14 @@ pub unsafe extern "C" fn dc_continue_key_transfer(
     }
     let ctx = &*context;
 
-    block_on(async move {
-        match imex::continue_key_transfer(ctx, MsgId::new(msg_id), &to_string_lossy(setup_code))
-            .await
-        {
-            Ok(()) => 1,
-            Err(err) => {
-                warn!(ctx, "dc_continue_key_transfer: {err:#}");
-                0
-            }
-        }
-    })
+    block_on(imex::continue_key_transfer(
+        ctx,
+        MsgId::new(msg_id),
+        &to_string_lossy(setup_code),
+    ))
+    .context("dc_continue_key_transfer")
+    .log_err(ctx)
+    .is_ok() as libc::c_int
 }
 
 #[no_mangle]
@@ -2916,12 +2867,14 @@ pub unsafe extern "C" fn dc_chatlist_get_chat_id(
     }
     let ffi_list = &*chatlist;
     let ctx = &*ffi_list.context;
-    match ffi_list.list.get_chat_id(index) {
+    match ffi_list
+        .list
+        .get_chat_id(index)
+        .context("get_chat_id failed")
+        .log_err(ctx)
+    {
         Ok(chat_id) => chat_id.to_u32(),
-        Err(err) => {
-            warn!(ctx, "get_chat_id failed: {err:#}");
-            0
-        }
+        Err(_) => 0,
     }
 }
 
@@ -2936,12 +2889,14 @@ pub unsafe extern "C" fn dc_chatlist_get_msg_id(
     }
     let ffi_list = &*chatlist;
     let ctx = &*ffi_list.context;
-    match ffi_list.list.get_msg_id(index) {
+    match ffi_list
+        .list
+        .get_msg_id(index)
+        .context("get_msg_id failed")
+        .log_err(ctx)
+    {
         Ok(msg_id) => msg_id.map_or(0, |msg_id| msg_id.to_u32()),
-        Err(err) => {
-            warn!(ctx, "get_msg_id failed: {err:#}");
-            0
-        }
+        Err(_) => 0,
     }
 }
 
@@ -3095,13 +3050,16 @@ pub unsafe extern "C" fn dc_chat_get_profile_image(chat: *mut dc_chat_t) -> *mut
     let ffi_chat = &*chat;
 
     block_on(async move {
-        match ffi_chat.chat.get_profile_image(&ffi_chat.context).await {
-            Ok(Some(p)) => p.to_string_lossy().strdup(),
-            Ok(None) => ptr::null_mut(),
-            Err(err) => {
-                error!(ffi_chat.context, "failed to get profile image: {err:#}");
-                ptr::null_mut()
-            }
+        match ffi_chat
+            .chat
+            .get_profile_image(&ffi_chat.context)
+            .await
+            .context("Failed to get profile image")
+            .log_err(&ffi_chat.context)
+            .unwrap_or_default()
+        {
+            Some(p) => p.to_string_lossy().strdup(),
+            None => ptr::null_mut(),
         }
     })
 }
@@ -3258,22 +3216,20 @@ pub unsafe extern "C" fn dc_chat_get_info_json(
     let ctx = &*context;
 
     block_on(async move {
-        let chat = match chat::Chat::load_from_db(ctx, ChatId::new(chat_id)).await {
-            Ok(chat) => chat,
-            Err(err) => {
-                error!(ctx, "dc_get_chat_info_json() failed to load chat: {err:#}");
-                return "".strdup();
-            }
+        let Ok(chat) = chat::Chat::load_from_db(ctx, ChatId::new(chat_id))
+            .await
+            .context("dc_get_chat_info_json() failed to load chat")
+            .log_err(ctx)
+        else {
+            return "".strdup();
         };
-        let info = match chat.get_info(ctx).await {
-            Ok(info) => info,
-            Err(err) => {
-                error!(
-                    ctx,
-                    "dc_get_chat_info_json() failed to get chat info: {err:#}"
-                );
-                return "".strdup();
-            }
+        let Ok(info) = chat
+            .get_info(ctx)
+            .await
+            .context("dc_get_chat_info_json() failed to get chat info")
+            .log_err(ctx)
+        else {
+            return "".strdup();
         };
         serde_json::to_string(&info)
             .unwrap_or_log_default(ctx, "dc_get_chat_info_json() failed to serialise to json")
@@ -3533,18 +3489,15 @@ pub unsafe extern "C" fn dc_msg_get_webxdc_info(msg: *mut dc_msg_t) -> *mut libc
     let ffi_msg = &*msg;
     let ctx = &*ffi_msg.context;
 
-    block_on(async move {
-        let info = match ffi_msg.message.get_webxdc_info(ctx).await {
-            Ok(info) => info,
-            Err(err) => {
-                error!(ctx, "dc_msg_get_webxdc_info() failed to get info: {err:#}");
-                return "".strdup();
-            }
-        };
-        serde_json::to_string(&info)
-            .unwrap_or_log_default(ctx, "dc_msg_get_webxdc_info() failed to serialise to json")
-            .strdup()
-    })
+    let Ok(info) = block_on(ffi_msg.message.get_webxdc_info(ctx))
+        .context("dc_msg_get_webxdc_info() failed to get info")
+        .log_err(ctx)
+    else {
+        return "".strdup();
+    };
+    serde_json::to_string(&info)
+        .unwrap_or_log_default(ctx, "dc_msg_get_webxdc_info() failed to serialise to json")
+        .strdup()
 }
 
 #[no_mangle]
@@ -4574,13 +4527,10 @@ trait ResultExt<T, E> {
 
 impl<T: Default, E: std::fmt::Display> ResultExt<T, E> for Result<T, E> {
     fn unwrap_or_log_default(self, context: &context::Context, message: &str) -> T {
-        match self {
-            Ok(t) => t,
-            Err(err) => {
-                error!(context, "{message}: {err:#}");
-                Default::default()
-            }
-        }
+        self.map_err(|err| anyhow::anyhow!("{err:#}"))
+            .with_context(|| message.to_string())
+            .log_err(context)
+            .unwrap_or_default()
     }
 }
 

deltachat-jsonrpc/src/api.rs

@@ -19,6 +19,7 @@ use deltachat::constants::DC_MSG_ID_DAYMARKER;
 use deltachat::contact::{may_be_valid_addr, Contact, ContactId, Origin};
 use deltachat::context::get_info;
 use deltachat::ephemeral::Timer;
+use deltachat::imex;
 use deltachat::location;
 use deltachat::message::get_msg_read_receipts;
 use deltachat::message::{
@@ -35,7 +36,6 @@ use deltachat::securejoin;
 use deltachat::stock_str::StockMessage;
 use deltachat::webxdc::StatusUpdateSerial;
 use deltachat::EventEmitter;
-use deltachat::{imex, info};
 use sanitize_filename::is_sanitized;
 use tokio::fs;
 use tokio::sync::{watch, Mutex, RwLock};
@@ -1919,12 +1919,10 @@ impl CommandApi {
         instance_msg_id: u32,
     ) -> Result<()> {
         let ctx = self.get_context(account_id).await?;
-        let fut = send_webxdc_realtime_advertisement(&ctx, MsgId::new(instance_msg_id)).await?;
-        if let Some(fut) = fut {
-            tokio::spawn(async move {
-                fut.await.ok();
-                info!(ctx, "send_webxdc_realtime_advertisement done")
-            });
+        if let Some(fut) =
+            send_webxdc_realtime_advertisement(&ctx, MsgId::new(instance_msg_id)).await?
+        {
+            tokio::spawn(fut);
         }
         Ok(())
     }

deltachat-repl/src/cmdline.rs

@@ -120,7 +120,7 @@ async fn poke_spec(context: &Context, spec: Option<&str>) -> bool {
     } else {
         let rs = context.sql().get_raw_config("import_spec").await.unwrap();
         if rs.is_none() {
-            error!(context, "Import: No file or folder given.");
+            eprintln!("Import: No file or folder given.");
             return false;
         }
         real_spec = rs.unwrap();
@@ -149,7 +149,7 @@ async fn poke_spec(context: &Context, spec: Option<&str>) -> bool {
                 }
             }
         } else {
-            error!(context, "Import: Cannot open directory \"{}\".", &real_spec);
+            eprintln!("Import: Cannot open directory \"{}\".", &real_spec);
             return false;
         }
     }

deltachat-repl/src/main.rs

@@ -5,7 +5,6 @@
 //! Usage:  cargo run --example repl --release -- <databasefile>
 //! All further options can be set using the set-command (type ? for help).
 
-#[macro_use]
 extern crate deltachat;
 
 use std::borrow::Cow::{self, Borrowed, Owned};

src/accounts.rs

@@ -18,6 +18,7 @@ use tokio::time::{sleep, Duration};
 
 use crate::context::{Context, ContextBuilder};
 use crate::events::{Event, EventEmitter, EventType, Events};
+use crate::log::{info, warn};
 use crate::push::PushSubscriber;
 use crate::stock_str::StockStrings;
 

src/blob.rs

@@ -20,7 +20,7 @@ use crate::config::Config;
 use crate::constants::{self, MediaQuality};
 use crate::context::Context;
 use crate::events::EventType;
-use crate::log::LogExt;
+use crate::log::{error, info, warn, LogExt};
 use crate::tools::sanitize_filename;
 
 /// Represents a file in the blob directory.

src/chat.rs

@@ -34,7 +34,7 @@ use crate::download::DownloadState;
 use crate::ephemeral::{start_chat_ephemeral_timers, Timer as EphemeralTimer};
 use crate::events::EventType;
 use crate::location;
-use crate::log::LogExt;
+use crate::log::{error, info, warn, LogExt};
 use crate::message::{self, Message, MessageState, MsgId, Viewtype};
 use crate::mimefactory::MimeFactory;
 use crate::mimeparser::SystemMessage;

src/chatlist.rs

@@ -10,6 +10,7 @@ use crate::constants::{
 };
 use crate::contact::{Contact, ContactId};
 use crate::context::Context;
+use crate::log::warn;
 use crate::message::{Message, MessageState, MsgId};
 use crate::param::{Param, Params};
 use crate::stock_str;

src/config.rs

@@ -17,7 +17,7 @@ use crate::configure::EnteredLoginParam;
 use crate::constants;
 use crate::context::Context;
 use crate::events::EventType;
-use crate::log::LogExt;
+use crate::log::{info, LogExt};
 use crate::login_param::ConfiguredLoginParam;
 use crate::mimefactory::RECOMMENDED_FILE_SIZE;
 use crate::provider::{get_provider_by_id, Provider};

src/configure.rs

@@ -27,7 +27,7 @@ use crate::config::{self, Config};
 use crate::constants::NON_ALPHANUMERIC_WITHOUT_DOT;
 use crate::context::Context;
 use crate::imap::Imap;
-use crate::log::LogExt;
+use crate::log::{info, warn, LogExt};
 pub use crate::login_param::EnteredLoginParam;
 use crate::login_param::{
     ConfiguredCertificateChecks, ConfiguredLoginParam, ConfiguredServerLoginParam,

src/configure/auto_mozilla.rs

@@ -9,6 +9,7 @@ use quick_xml::events::{BytesStart, Event};
 
 use super::{Error, ServerParams};
 use crate::context::Context;
+use crate::log::warn;
 use crate::net::read_url;
 use crate::provider::{Protocol, Socket};
 

src/configure/auto_outlook.rs

@@ -9,6 +9,7 @@ use quick_xml::events::Event;
 
 use super::{Error, ServerParams};
 use crate::context::Context;
+use crate::log::warn;
 use crate::net::read_url;
 use crate::provider::{Protocol, Socket};
 

src/contact.rs

@@ -29,7 +29,7 @@ use crate::constants::{Blocked, Chattype, DC_GCL_ADD_SELF};
 use crate::context::Context;
 use crate::events::EventType;
 use crate::key::{load_self_public_key, DcKey, SignedPublicKey};
-use crate::log::LogExt;
+use crate::log::{info, warn, LogExt};
 use crate::message::MessageState;
 use crate::mimeparser::AvatarAction;
 use crate::param::{Param, Params};

src/context.rs

@@ -28,6 +28,7 @@ use crate::download::DownloadState;
 use crate::events::{Event, EventEmitter, EventType, Events};
 use crate::imap::{FolderMeaning, Imap, ServerMetadata};
 use crate::key::{load_self_public_key, load_self_secret_key, DcKey as _};
+use crate::log::{info, warn};
 use crate::login_param::{ConfiguredLoginParam, EnteredLoginParam};
 use crate::message::{self, Message, MessageState, MsgId};
 use crate::param::{Param, Params};

src/debug_logging.rs

@@ -3,6 +3,7 @@ use crate::chat::ChatId;
 use crate::config::Config;
 use crate::context::Context;
 use crate::events::EventType;
+use crate::log::{error, info};
 use crate::message::{Message, MsgId, Viewtype};
 use crate::param::Param;
 use crate::tools::time;

src/decrypt.rs

@@ -9,6 +9,7 @@ use mailparse::ParsedMail;
 use crate::aheader::Aheader;
 use crate::context::Context;
 use crate::key::{DcKey, Fingerprint, SignedPublicKey, SignedSecretKey};
+use crate::log::info;
 use crate::peerstate::Peerstate;
 use crate::pgp;
 

src/download.rs

@@ -10,6 +10,7 @@ use serde::{Deserialize, Serialize};
 use crate::config::Config;
 use crate::context::Context;
 use crate::imap::session::Session;
+use crate::log::info;
 use crate::message::{Message, MsgId, Viewtype};
 use crate::mimeparser::{MimeMessage, Part};
 use crate::tools::time;

src/e2ee.rs

@@ -11,6 +11,7 @@ use crate::aheader::{Aheader, EncryptPreference};
 use crate::config::Config;
 use crate::context::Context;
 use crate::key::{load_self_public_key, load_self_secret_key, SignedPublicKey};
+use crate::log::warn;
 use crate::peerstate::Peerstate;
 use crate::pgp;
 

src/ephemeral.rs

@@ -81,7 +81,7 @@ use crate::context::Context;
 use crate::download::MIN_DELETE_SERVER_AFTER;
 use crate::events::EventType;
 use crate::location;
-use crate::log::LogExt;
+use crate::log::{error, info, warn, LogExt};
 use crate::message::{Message, MessageState, MsgId, Viewtype};
 use crate::mimeparser::SystemMessage;
 use crate::stock_str;

src/html.rs

@@ -16,6 +16,7 @@ use mime::Mime;
 
 use crate::context::Context;
 use crate::headerdef::{HeaderDef, HeaderDefMap};
+use crate::log::warn;
 use crate::message::{self, Message, MsgId};
 use crate::mimeparser::parse_message_id;
 use crate::param::Param::SendHtml;

src/imap.rs

@@ -32,7 +32,7 @@ use crate::contact::{Contact, ContactId, Modifier, Origin};
 use crate::context::Context;
 use crate::events::EventType;
 use crate::headerdef::{HeaderDef, HeaderDefMap};
-use crate::log::LogExt;
+use crate::log::{error, info, warn, LogExt};
 use crate::login_param::{
     prioritize_server_login_params, ConfiguredLoginParam, ConfiguredServerLoginParam,
 };

src/imap/client.rs

@@ -8,6 +8,7 @@ use tokio::io::BufWriter;
 
 use super::capabilities::Capabilities;
 use crate::context::Context;
+use crate::log::{info, warn};
 use crate::login_param::{ConnectionCandidate, ConnectionSecurity};
 use crate::net::dns::{lookup_host_with_cache, update_connect_timestamp};
 use crate::net::proxy::ProxyConfig;

src/imap/idle.rs

@@ -8,6 +8,7 @@ use tokio::time::timeout;
 use super::session::Session;
 use super::Imap;
 use crate::context::Context;
+use crate::log::{info, warn};
 use crate::net::TIMEOUT;
 use crate::tools::{self, time_elapsed};
 

src/imap/scan_folders.rs

@@ -5,7 +5,7 @@ use anyhow::{Context as _, Result};
 use super::{get_folder_meaning_by_attrs, get_folder_meaning_by_name};
 use crate::config::Config;
 use crate::imap::{session::Session, Imap};
-use crate::log::LogExt;
+use crate::log::{info, LogExt};
 use crate::tools::{self, time_elapsed};
 use crate::{context::Context, imap::FolderMeaning};
 

src/imap/select_folder.rs

@@ -5,6 +5,7 @@ use anyhow::Context as _;
 use super::session::Session as ImapSession;
 use super::{get_uid_next, get_uidvalidity, set_modseq, set_uid_next, set_uidvalidity};
 use crate::context::Context;
+use crate::log::{info, warn};
 
 type Result<T> = std::result::Result<T, Error>;
 

src/imex.rs

@@ -20,7 +20,7 @@ use crate::context::Context;
 use crate::e2ee;
 use crate::events::EventType;
 use crate::key::{self, DcKey, DcSecretKey, SignedPublicKey, SignedSecretKey};
-use crate::log::LogExt;
+use crate::log::{error, info, warn, LogExt};
 use crate::pgp;
 use crate::qr::DCBACKUP_VERSION;
 use crate::sql;

src/imex/transfer.rs

@@ -41,6 +41,7 @@ use tokio_util::sync::CancellationToken;
 use crate::chat::add_device_msg;
 use crate::context::Context;
 use crate::imex::BlobDirContents;
+use crate::log::{info, warn};
 use crate::message::Message;
 use crate::qr::Qr;
 use crate::stock_str::backup_transfer_msg_body;

src/key.rs

@@ -15,7 +15,7 @@ use rand::thread_rng;
 use tokio::runtime::Handle;
 
 use crate::context::Context;
-use crate::log::LogExt;
+use crate::log::{info, LogExt};
 use crate::pgp::KeyPair;
 use crate::tools::{self, time_elapsed};
 

src/location.rs

@@ -22,6 +22,7 @@ use crate::constants::DC_CHAT_ID_TRASH;
 use crate::contact::ContactId;
 use crate::context::Context;
 use crate::events::EventType;
+use crate::log::{info, warn};
 use crate::message::{Message, MsgId, Viewtype};
 use crate::mimeparser::SystemMessage;
 use crate::tools::{duration_to_str, time};

src/log.rs

@@ -4,7 +4,6 @@
 
 use crate::context::Context;
 
-#[macro_export]
 macro_rules! info {
     ($ctx:expr,  $msg:expr) => {
         info!($ctx, $msg,)
@@ -19,22 +18,30 @@ macro_rules! info {
     }};
 }
 
-#[macro_export]
-macro_rules! warn {
-    ($ctx:expr, $msg:expr) => {
-        warn!($ctx, $msg,)
-    };
-    ($ctx:expr, $msg:expr, $($args:expr),* $(,)?) => {{
-        let formatted = format!($msg, $($args),*);
-        let full = format!("{file}:{line}: {msg}",
-                           file = file!(),
-                           line = line!(),
-                           msg = &formatted);
-        $ctx.emit_event($crate::EventType::Warning(full));
-    }};
+pub(crate) use info;
+
+// Workaround for <https://github.com/rust-lang/rust/issues/133708>.
+#[macro_use]
+mod warn_macro_mod {
+    macro_rules! warn_macro {
+        ($ctx:expr, $msg:expr) => {
+            warn_macro!($ctx, $msg,)
+        };
+        ($ctx:expr, $msg:expr, $($args:expr),* $(,)?) => {{
+            let formatted = format!($msg, $($args),*);
+            let full = format!("{file}:{line}: {msg}",
+                               file = file!(),
+                               line = line!(),
+                               msg = &formatted);
+            $ctx.emit_event($crate::EventType::Warning(full));
+        }};
+    }
+
+    pub(crate) use warn_macro;
 }
 
-#[macro_export]
+pub(crate) use warn_macro_mod::warn_macro as warn;
+
 macro_rules! error {
     ($ctx:expr, $msg:expr) => {
         error!($ctx, $msg,)
@@ -46,6 +53,8 @@ macro_rules! error {
     }};
 }
 
+pub(crate) use error;
+
 impl Context {
     /// Set last error string.
     /// Implemented as blocking as used from macros in different, not always async blocks.
@@ -102,6 +111,8 @@ impl<T, E: std::fmt::Display> LogExt<T, E> for Result<T, E> {
 
 #[cfg(test)]
 mod tests {
+    use super::*;
+
     use anyhow::Result;
 
     use crate::test_utils::TestContext;

src/message.rs

@@ -26,6 +26,7 @@ use crate::ephemeral::{start_ephemeral_timers_msgids, Timer as EphemeralTimer};
 use crate::events::EventType;
 use crate::imap::markseen_on_imap_table;
 use crate::location::delete_poi_location;
+use crate::log::{error, info, warn};
 use crate::mimeparser::{parse_message_id, SystemMessage};
 use crate::param::{Param, Params};
 use crate::pgp::split_armored_data;

src/mimefactory.rs

@@ -25,6 +25,7 @@ use crate::e2ee::EncryptHelper;
 use crate::ephemeral::Timer as EphemeralTimer;
 use crate::key::DcKey;
 use crate::location;
+use crate::log::{info, warn};
 use crate::message::{self, Message, MsgId, Viewtype};
 use crate::mimeparser::{is_hidden, SystemMessage};
 use crate::param::Param;
@@ -32,9 +33,9 @@ use crate::peer_channels::create_iroh_header;
 use crate::peerstate::Peerstate;
 use crate::simplify::escape_message_footer_marks;
 use crate::stock_str;
-use crate::tools::IsNoneOrEmpty;
 use crate::tools::{
     create_outgoing_rfc724_mid, create_smeared_timestamp, remove_subject_prefix, time,
+    IsNoneOrEmpty,
 };
 use crate::webxdc::StatusUpdateSerial;
 

src/mimeparser.rs

@@ -29,14 +29,14 @@ use crate::dehtml::dehtml;
 use crate::events::EventType;
 use crate::headerdef::{HeaderDef, HeaderDefMap};
 use crate::key::{self, load_self_secret_keyring, DcKey, Fingerprint, SignedPublicKey};
+use crate::log::{error, info, warn};
 use crate::message::{self, get_vcard_summary, set_msg_failed, Message, MsgId, Viewtype};
 use crate::param::{Param, Params};
 use crate::peerstate::Peerstate;
 use crate::simplify::{simplify, SimplifiedText};
 use crate::sync::SyncItems;
-use crate::tools::time;
 use crate::tools::{
-    get_filemeta, parse_receive_headers, smeared_time, truncate_msg_text, validate_id,
+    get_filemeta, parse_receive_headers, smeared_time, time, truncate_msg_text, validate_id,
 };
 use crate::{chatlist_events, location, stock_str, tools};
 

src/net/dns.rs

@@ -50,6 +50,7 @@ use tokio::time::timeout;
 
 use super::load_connection_timestamp;
 use crate::context::Context;
+use crate::log::{info, warn};
 use crate::tools::time;
 
 /// Inserts entry into DNS cache

src/net/http.rs

@@ -10,6 +10,7 @@ use tokio::fs;
 
 use crate::blob::BlobObject;
 use crate::context::Context;
+use crate::log::{info, warn};
 use crate::net::proxy::ProxyConfig;
 use crate::net::session::SessionStream;
 use crate::net::tls::wrap_rustls;

src/oauth2.rs

@@ -7,6 +7,7 @@ use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
 use serde::Deserialize;
 
 use crate::context::Context;
+use crate::log::{info, warn};
 use crate::net::http::post_form;
 use crate::net::read_url_blob;
 use crate::provider;

src/peer_channels.rs

@@ -39,6 +39,7 @@ use url::Url;
 use crate::chat::send_msg;
 use crate::config::Config;
 use crate::context::Context;
+use crate::log::{info, warn};
 use crate::message::{Message, MsgId, Viewtype};
 use crate::mimeparser::SystemMessage;
 use crate::EventType;

src/peerstate.rs

@@ -15,6 +15,7 @@ use crate::contact::{Contact, Origin};
 use crate::context::Context;
 use crate::events::EventType;
 use crate::key::{DcKey, Fingerprint, SignedPublicKey};
+use crate::log::{info, warn};
 use crate::message::Message;
 use crate::mimeparser::SystemMessage;
 use crate::sql::Sql;

src/provider.rs

@@ -10,6 +10,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::config::Config;
 use crate::context::Context;
+use crate::log::warn;
 use crate::provider::data::{PROVIDER_DATA, PROVIDER_IDS};
 
 /// Provider status according to manual testing.

src/quota.rs

@@ -11,6 +11,7 @@ use crate::config::Config;
 use crate::context::Context;
 use crate::imap::scan_folders::get_watched_folders;
 use crate::imap::session::Session as ImapSession;
+use crate::log::warn;
 use crate::message::Message;
 use crate::tools::{self, time_elapsed};
 use crate::{stock_str, EventType};

src/reaction.rs

@@ -26,6 +26,7 @@ use crate::chatlist_events;
 use crate::contact::ContactId;
 use crate::context::Context;
 use crate::events::EventType;
+use crate::log::info;
 use crate::message::{rfc724_mid_exists, Message, MsgId};
 use crate::param::Param;
 

src/receive_imf.rs

@@ -26,6 +26,7 @@ use crate::headerdef::{HeaderDef, HeaderDefMap};
 use crate::imap::{markseen_on_imap_table, GENERATED_PREFIX};
 use crate::key::DcKey;
 use crate::log::LogExt;
+use crate::log::{info, warn};
 use crate::message::{
     self, rfc724_mid_exists, Message, MessageState, MessengerMessage, MsgId, Viewtype,
 };

src/scheduler.rs

@@ -21,7 +21,7 @@ use crate::ephemeral::{self, delete_expired_imap_messages};
 use crate::events::EventType;
 use crate::imap::{session::Session, FolderMeaning, Imap};
 use crate::location;
-use crate::log::LogExt;
+use crate::log::{error, info, warn, LogExt};
 use crate::message::MsgId;
 use crate::smtp::{send_smtp_messages, Smtp};
 use crate::sql;

src/scheduler/connectivity.rs

@@ -8,6 +8,7 @@ use tokio::sync::Mutex;
 
 use crate::events::EventType;
 use crate::imap::{scan_folders::get_watched_folder_configs, FolderMeaning};
+use crate::log::info;
 use crate::quota::{QUOTA_ERROR_THRESHOLD_PERCENTAGE, QUOTA_WARN_THRESHOLD_PERCENTAGE};
 use crate::stock_str;
 use crate::{context::Context, log::LogExt};

src/securejoin.rs

@@ -14,6 +14,7 @@ use crate::e2ee::ensure_secret_key_exists;
 use crate::events::EventType;
 use crate::headerdef::HeaderDef;
 use crate::key::{load_self_public_key, DcKey, Fingerprint};
+use crate::log::{error, info, warn};
 use crate::message::{Message, Viewtype};
 use crate::mimeparser::{MimeMessage, SystemMessage};
 use crate::param::Param;

src/securejoin/bob.rs

@@ -10,6 +10,7 @@ use crate::contact::Origin;
 use crate::context::Context;
 use crate::events::EventType;
 use crate::key::{load_self_public_key, DcKey};
+use crate::log::info;
 use crate::message::{Message, Viewtype};
 use crate::mimeparser::{MimeMessage, SystemMessage};
 use crate::param::Param;

src/smtp.rs

@@ -13,6 +13,7 @@ use crate::config::Config;
 use crate::contact::{Contact, ContactId};
 use crate::context::Context;
 use crate::events::EventType;
+use crate::log::{error, info, warn};
 use crate::login_param::prioritize_server_login_params;
 use crate::login_param::{ConfiguredLoginParam, ConfiguredServerLoginParam};
 use crate::message::Message;

src/smtp/connect.rs

@@ -7,6 +7,7 @@ use async_smtp::{SmtpClient, SmtpTransport};
 use tokio::io::{AsyncBufRead, AsyncWrite, BufStream};
 
 use crate::context::Context;
+use crate::log::{info, warn};
 use crate::login_param::{ConnectionCandidate, ConnectionSecurity};
 use crate::net::dns::{lookup_host_with_cache, update_connect_timestamp};
 use crate::net::proxy::ProxyConfig;

src/smtp/send.rs

@@ -6,6 +6,7 @@ use super::Smtp;
 use crate::config::Config;
 use crate::context::Context;
 use crate::events::EventType;
+use crate::log::{info, warn};
 use crate::tools;
 
 pub type Result<T> = std::result::Result<T, Error>;

src/sql.rs

@@ -16,7 +16,7 @@ use crate::debug_logging::set_debug_logging_xdc;
 use crate::ephemeral::start_ephemeral_timers;
 use crate::imex::BLOBS_BACKUP_NAME;
 use crate::location::delete_orphaned_poi_locations;
-use crate::log::LogExt;
+use crate::log::{error, info, warn, LogExt};
 use crate::message::{Message, MsgId};
 use crate::net::dns::prune_dns_cache;
 use crate::net::http::http_cache_cleanup;

src/sql/migrations.rs

@@ -9,6 +9,7 @@ use crate::configure::EnteredLoginParam;
 use crate::constants::ShowEmails;
 use crate::context::Context;
 use crate::imap;
+use crate::log::{info, warn};
 use crate::login_param::ConfiguredLoginParam;
 use crate::message::MsgId;
 use crate::provider::get_provider_by_domain;

src/sync.rs

@@ -10,6 +10,7 @@ use crate::constants::Blocked;
 use crate::contact::ContactId;
 use crate::context::Context;
 use crate::log::LogExt;
+use crate::log::{info, warn};
 use crate::message::{Message, MsgId, Viewtype};
 use crate::mimeparser::SystemMessage;
 use crate::param::Param;

src/test_utils.rs

@@ -33,6 +33,7 @@ use crate::context::Context;
 use crate::e2ee::EncryptHelper;
 use crate::events::{Event, EventEmitter, EventType, Events};
 use crate::key::{self, DcKey, DcSecretKey};
+use crate::log::warn;
 use crate::message::{update_msg_state, Message, MessageState, MsgId, Viewtype};
 use crate::mimeparser::{MimeMessage, SystemMessage};
 use crate::peerstate::Peerstate;

src/tools.rs

@@ -41,6 +41,7 @@ use crate::config::Config;
 use crate::constants::{self, DC_ELLIPSIS, DC_OUTDATED_WARNING_DAYS};
 use crate::context::Context;
 use crate::events::EventType;
+use crate::log::warn;
 use crate::message::{Message, Viewtype};
 use crate::stock_str;
 

src/webxdc.rs

@@ -40,13 +40,13 @@ use crate::contact::ContactId;
 use crate::context::Context;
 use crate::events::EventType;
 use crate::key::{load_self_public_key, DcKey};
+use crate::log::{info, warn};
 use crate::message::{Message, MessageState, MsgId, Viewtype};
 use crate::mimefactory::RECOMMENDED_FILE_SIZE;
 use crate::mimeparser::SystemMessage;
 use crate::param::Param;
 use crate::param::Params;
-use crate::tools::create_id;
-use crate::tools::{create_smeared_timestamp, get_abs_path};
+use crate::tools::{create_id, create_smeared_timestamp, get_abs_path};
 
 /// The current API version.
 /// If `min_api` in manifest.toml is set to a larger value,

src/webxdc/maps_integration.rs

@@ -41,6 +41,7 @@ use crate::message::{Message, MsgId};
 use crate::chat::ChatId;
 use crate::color::color_int_to_hex_string;
 use crate::contact::{Contact, ContactId};
+use crate::log::warn;
 use crate::tools::time;
 use crate::webxdc::{StatusUpdateItem, StatusUpdateItemAndSerial, StatusUpdateSerial};
 use anyhow::Result;