Make self reporting into a setting

Author: Hocuri

deltachat-jsonrpc/src/api.rs

@@ -375,9 +375,10 @@ impl CommandApi {
         Ok(BlobObject::create_and_deduplicate(&ctx, file, file)?.to_abs_path())
     }
 
+    /// Deprecated 2025-04. Use the "self_reporting" config instead.
     async fn draft_self_report(&self, account_id: u32) -> Result<u32> {
         let ctx = self.get_context(account_id).await?;
-        Ok(ctx.draft_self_report().await?.to_u32())
+        Ok(ctx.send_self_report().await?.to_u32())
     }
 
     /// Sets the given configuration key.

src/config.rs

@@ -428,6 +428,13 @@ pub enum Config {
     /// used for signatures, encryption to self and included in `Autocrypt` header.
     KeyId,
 
+    /// Send statistics to Delta Chat's developers.
+    /// Can be exposed to the user as a setting.
+    SelfReporting,
+
+    /// Last time statistics were sent to Delta Chat's developers
+    LastSelfReportSent,
+
     /// This key is sent to the self_reporting bot so that the bot can recognize the user
     /// without storing the email address
     SelfReportingId,

src/context.rs

@@ -8,32 +8,33 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, OnceLock};
 use std::time::Duration;
 
-use anyhow::{Context as _, Result, bail, ensure};
+use anyhow::{bail, ensure, Context as _, Result};
 use async_channel::{self as channel, Receiver, Sender};
 use pgp::types::PublicKeyTrait;
 use ratelimit::Ratelimit;
 use tokio::sync::{Mutex, Notify, RwLock};
 
-use crate::chat::{ChatId, ProtectionStatus, get_chat_cnt};
+use crate::chat::{get_chat_cnt, ChatId, ProtectionStatus};
 use crate::chatlist_events;
 use crate::config::Config;
 use crate::constants::{
     self, DC_BACKGROUND_FETCH_QUOTA_CHECK_RATELIMIT, DC_CHAT_ID_TRASH, DC_VERSION_STR,
 };
-use crate::contact::{Contact, ContactId, import_vcard, mark_contact_id_as_verified};
+use crate::contact::{import_vcard, mark_contact_id_as_verified, Contact, ContactId};
 use crate::debug_logging::DebugLogging;
 use crate::download::DownloadState;
 use crate::events::{Event, EventEmitter, EventType, Events};
 use crate::imap::{FolderMeaning, Imap, ServerMetadata};
-use crate::key::{load_self_secret_key, self_fingerprint};
+use crate::key::{load_self_public_key, load_self_secret_key, DcKey as _};
+use crate::log::LogExt;
 use crate::log::{info, warn};
 use crate::login_param::{ConfiguredLoginParam, EnteredLoginParam};
-use crate::message::{self, Message, MessageState, MsgId};
+use crate::message::{self, Message, MessageState, MsgId, Viewtype};
 use crate::param::{Param, Params};
 use crate::peer_channels::Iroh;
 use crate::push::PushSubscriber;
 use crate::quota::QuotaInfo;
-use crate::scheduler::{SchedulerState, convert_folder_meaning};
+use crate::scheduler::{convert_folder_meaning, SchedulerState};
 use crate::sql::Sql;
 use crate::stock_str::StockStrings;
 use crate::timesmearing::SmearedTimestamp;
@@ -1041,6 +1042,18 @@ impl Context {
                 .await?
                 .to_string(),
         );
+        res.insert(
+            "self_reporting",
+            self.get_config_bool(Config::SelfReporting)
+                .await?
+                .to_string(),
+        );
+        res.insert(
+            "last_self_report_sent",
+            self.get_config_i64(Config::LastSelfReportSent)
+                .await?
+                .to_string(),
+        );
 
         let elapsed = time_elapsed(&self.creation_time);
         res.insert("uptime", duration_to_str(elapsed));
@@ -1160,7 +1173,8 @@ impl Context {
             Some(id) => id,
             None => {
                 let id = create_id();
-                self.set_config(Config::SelfReportingId, Some(&id)).await?;
+                self.set_config_internal(Config::SelfReportingId, Some(&id))
+                    .await?;
                 id
             }
         };
@@ -1174,7 +1188,15 @@ impl Context {
     ///
     /// On the other end, a bot will receive the message and make it available
     /// to Delta Chat's developers.
-    pub async fn draft_self_report(&self) -> Result<ChatId> {
+    pub async fn send_self_report(&self) -> Result<ChatId> {
+        info!(self, "Sending self report.");
+        // Setting `Config::LastHousekeeping` at the beginning avoids endless loops when things do not
+        // work out for whatever reason or are interrupted by the OS.
+        self.set_config_internal(Config::LastSelfReportSent, Some(&time().to_string()))
+            .await
+            .log_err(self)
+            .ok();
+
         const SELF_REPORTING_BOT_VCARD: &str = include_str!("../assets/self-reporting-bot.vcf");
         let contact_id: ContactId = *import_vcard(self, SELF_REPORTING_BOT_VCARD)
             .await?
@@ -1187,9 +1209,26 @@ impl Context {
             .set_protection(self, ProtectionStatus::Protected, time(), Some(contact_id))
             .await?;
 
-        let mut msg = Message::new_text(self.get_self_report().await?);
+        let mut msg = Message::new(Viewtype::File);
+        msg.set_text(
+            "The attachment contains anonymous usage statistics, \
+because you enabled this in the settings. \
+This helps us improve the security of Delta Chat. \
+See TODO[blog post] for more information."
+                .to_string(),
+        );
+        msg.set_file_from_bytes(
+            self,
+            "statistics.txt",
+            self.get_self_report().await?.as_bytes(),
+            Some("text/plain"),
+        )?;
 
-        chat_id.set_draft(self, Some(&mut msg)).await?;
+        crate::chat::send_msg(self, chat_id, &mut msg)
+            .await
+            .context("Failed to send self_reporting message")
+            .log_err(self)
+            .ok();
 
         Ok(chat_id)
     }

src/context/context_tests.rs

@@ -602,18 +602,15 @@ async fn test_get_next_msgs() -> Result<()> {
 async fn test_draft_self_report() -> Result<()> {
     let alice = TestContext::new_alice().await;
 
-    let chat_id = alice.draft_self_report().await?;
-    let msg = get_chat_msg(&alice, chat_id, 0, 1).await;
+    let chat_id = alice.send_self_report().await?;
+    let msg = get_chat_msg(&alice, chat_id, 0, 2).await;
     assert_eq!(msg.get_info_type(), SystemMessage::ChatProtectionEnabled);
 
     let chat = Chat::load_from_db(&alice, chat_id).await?;
     assert!(chat.is_protected());
 
-    let mut draft = chat_id.get_draft(&alice).await?.unwrap();
-    assert!(draft.text.starts_with("core_version"));
-
-    // Test that sending into the protected chat works:
-    let _sent = alice.send_msg(chat_id, &mut draft).await;
+    let statistics_msg = get_chat_msg(&alice, chat_id, 1, 2).await;
+    assert_eq!(statistics_msg.get_filename().unwrap(), "statistics.txt");
 
     Ok(())
 }

src/scheduler.rs

@@ -507,6 +507,20 @@ async fn inbox_fetch_idle(ctx: &Context, imap: &mut Imap, mut session: Session)
         }
     };
 
+    //#[cfg(target_os = "android")] TODO
+    if ctx.get_config_bool(Config::SelfReporting).await? {
+        match ctx.get_config_i64(Config::LastSelfReportSent).await {
+            Ok(last_selfreport_time) => {
+                let next_selfreport_time = last_selfreport_time.saturating_add(30); // TODO increase to 1 day or 1 week
+                if next_selfreport_time <= time() {
+                    ctx.send_self_report().await?;
+                }
+            }
+            Err(err) => {
+                warn!(ctx, "Failed to get last self_reporting time: {}", err);
+            }
+        }
+    }
     match ctx.get_config_bool(Config::FetchedExistingMsgs).await {
         Ok(fetched_existing_msgs) => {
             if !fetched_existing_msgs {