Privacy Compliance Guide

use telemetry_kit::prelude::*;
 
#[tokio::main]
async fn main() -> telemetry_kit::Result<()> {
    // Initialize with consent requirement
    let telemetry = TelemetryKit::builder()
        .service_name("my-app")?
        .service_version(env!("CARGO_PKG_VERSION"))
        .strict_privacy()  // Enables GDPR-compliant defaults
        .build()?;
 
    // Events will be silently ignored until consent is granted
    Ok(())
}

use telemetry_kit::prelude::*;
use dialoguer::Confirm;
 
#[tokio::main]
async fn main() -> telemetry_kit::Result<()> {
    let telemetry = TelemetryKit::builder()
        .service_name("my-app")?
        .service_version("1.0.0")
        .consent_required(true)
        .build()?;
 
    // Show GDPR-compliant consent dialog
    let consent_text = r#"
Privacy Notice & Consent Request
 
We collect anonymous usage telemetry to improve our software.
 
Data Collected:
  • Command usage and feature utilization
  • Success/failure status of operations
  • Performance metrics (timing, not content)
  • Operating system and architecture
 
Privacy Guarantees:
  ✓ All data is anonymized
  ✓ No personal information (PII) is collected
  ✓ User IDs are SHA-256 hashed
  ✓ File paths are sanitized (usernames removed)
  ✓ Email addresses are hashed if detected
 
Your Rights:
  • Access your data: telemetry-kit events export
  • Delete your data: telemetry-kit events clear
  • Withdraw consent: telemetry-kit consent deny
  • Opt out anytime: export DO_NOT_TRACK=1
 
Data Retention: 30 days
 
Legal Basis: Consent (GDPR Art. 6(1)(a))
 
Controller: [Your Organization Name]
Contact: privacy@example.com
 
"#;
 
    println!("{}", consent_text);
 
    if Confirm::new()
        .with_prompt("Do you consent to anonymous telemetry collection?")
        .default(false)
        .interact()
        .unwrap_or(false)
    {
        telemetry.grant_consent()?;
        println!("✓ Consent granted. Thank you!");
    } else {
        telemetry.deny_consent()?;
        println!("✓ Consent denied. No data will be collected.");
    }
 
    // Your application logic
    telemetry.shutdown().await?;
    Ok(())
}

// ✅ GOOD: Necessary, anonymized data
telemetry.track_command("build", |event| {
    event
        .flag("--release")
        .success(true)
        .duration_ms(1234)
}).await?;
 
// ✅ GOOD: Aggregated metrics
telemetry.track_event("feature_usage", |event| {
    event.property("feature", "syntax_highlighting")
}).await?;

// ❌ BAD: Personal information
telemetry.track_event("user", |event| {
    event
        .property("name", "John Doe")           // ❌ PII
        .property("email", "john@example.com")  // ❌ PII
        .property("ip", "192.168.1.1")          // ❌ PII
}).await?;
 
// ❌ BAD: File contents
telemetry.track_event("file", |event| {
    event.property("contents", file_contents)   // ❌ Potentially sensitive
}).await?;

# CLI command for users
telemetry-kit events export --format json > my-data.json

// Programmatic access
let events = telemetry.export_events().await?;
println!("Your telemetry data: {}", serde_json::to_string_pretty(&events)?);

# CLI command
telemetry-kit events clear

// Programmatic deletion
telemetry.clear_all_events().await?;
println!("✓ All your telemetry data has been deleted.");

# Export as JSON
telemetry-kit events export --format json > data.json
 
# Export as CSV
telemetry-kit events export --format csv > data.csv

# User can opt out anytime
export DO_NOT_TRACK=1

// Always check DO_NOT_TRACK
if TelemetryKit::is_do_not_track_enabled() {
    println!("Telemetry disabled per user request");
    return Ok(());
}

let telemetry = TelemetryKit::builder()
    .service_name("my-app")?
    .data_retention(30)  // 30 days (GDPR-compliant)
    .build()?;
 
// Periodically clean up old data
let deleted = telemetry.cleanup().await?;
println!("Deleted {} events older than 30 days", deleted);

use telemetry_kit::privacy::PrivacyManager;
 
// Paths are automatically sanitized
let safe_path = PrivacyManager::sanitize_path("/Users/john/Documents/secret.txt");
println!("{}", safe_path); // Output: ~/Documents/secret.txt
 
// Emails are automatically hashed
let safe_email = PrivacyManager::sanitize_email("user@example.com");
println!("{}", safe_email); // Output: email_b4c9a289323b21a0

let telemetry = TelemetryKit::builder()
    .service_name("my-app")?
    .sanitize_paths(true)   // Remove usernames from paths
    .sanitize_emails(true)  // Hash email addresses
    .build()?;

# Privacy Notice
 
## Data Controller
[Your Organization Name]
[Address]
[Contact Email]
 
## Data We Collect
We collect anonymous usage telemetry to improve our software:
 
- Command usage and feature utilization
- Success/failure status of operations
- Performance metrics (timing, not content)
- Operating system and architecture
 
## Legal Basis
Consent (GDPR Article 6(1)(a))
 
## Data Processing
- All data is anonymized using SHA-256 hashing
- File paths are sanitized to remove usernames
- Email addresses are hashed if detected
- No personal identifiable information (PII) is collected
 
## Data Retention
Telemetry data is retained for 30 days and then automatically deleted.
 
## Your Rights
You have the right to:
 
- **Access** your data: `telemetry-kit events export`
- **Delete** your data: `telemetry-kit events clear`
- **Withdraw consent**: `telemetry-kit consent deny`
- **Opt out**: Set `DO_NOT_TRACK=1` environment variable
 
## Data Transfers
[If applicable, describe any data transfers outside EU]
 
## Contact
For privacy inquiries: privacy@example.com
Data Protection Officer: dpo@example.com
 
## Last Updated
[Date]

use telemetry_kit::prelude::*;
 
fn show_ccpa_notice() {
    println!(r#"
NOTICE OF DATA COLLECTION (CCPA)
 
We collect the following categories of information:
  • Usage data (commands, features used)
  • Performance metrics (timing, success/failure)
  • Device information (OS, architecture)
 
Purpose: Improve software quality and user experience
 
Your Rights:
  • Right to Know: telemetry-kit events export
  • Right to Delete: telemetry-kit events clear
  • Right to Opt-Out: export DO_NOT_TRACK=1
 
For more information: privacy@example.com
"#);
}
 
#[tokio::main]
async fn main() -> telemetry_kit::Result<()> {
    // Show notice on first run
    let consent_file = dirs::home_dir()
        .unwrap()
        .join(".telemetry-kit")
        .join("consent.json");
 
    if !consent_file.exists() {
        show_ccpa_notice();
    }
 
    let telemetry = TelemetryKit::builder()
        .service_name("my-app")?
        .build()?;
 
    // Your application logic
    telemetry.shutdown().await?;
    Ok(())
}

// Always respect DO_NOT_TRACK
if TelemetryKit::is_do_not_track_enabled() {
    println!("✓ Telemetry opt-out respected (DO_NOT_TRACK=1)");
    return Ok(());
}

## How to Opt Out of Telemetry
 
Set the DO_NOT_TRACK environment variable:
 
bash
# Permanently (add to ~/.bashrc or ~/.zshrc)
export DO_NOT_TRACK=1
 
# For a single command
DO_NOT_TRACK=1 my-app build

use telemetry_kit::prelude::*;
 
async fn handle_data_request(telemetry: &TelemetryKit) -> telemetry_kit::Result<()> {
    println!("Exporting your telemetry data...");
 
    let events = telemetry.export_events().await?;
    let json = serde_json::to_string_pretty(&events)?;
 
    std::fs::write("my-telemetry-data.json", json)?;
    println!("✓ Data exported to my-telemetry-data.json");
 
    Ok(())
}

async fn handle_deletion_request(telemetry: &TelemetryKit) -> telemetry_kit::Result<()> {
    println!("Deleting all your telemetry data...");
 
    telemetry.clear_all_events().await?;
    telemetry.deny_consent()?;
 
    println!("✓ All data deleted and future collection disabled");
 
    Ok(())
}

use telemetry_kit::prelude::*;
 
#[tokio::main]
async fn main() -> telemetry_kit::Result<()> {
    // Detect user location (example)
    let user_location = detect_user_location();
 
    let telemetry = match user_location {
        "EU" => {
            // GDPR: Require explicit consent
            TelemetryKit::builder()
                .service_name("my-app")?
                .strict_privacy()      // 30-day retention
                .consent_required(true)
                .prompt_for_consent()? // Interactive prompt
                .build()?
        }
        "CA" => {
            // CCPA: Opt-out model
            show_ccpa_notice();
            TelemetryKit::builder()
                .service_name("my-app")?
                .data_retention(90)
                .build()?
        }
        _ => {
            // Default: Privacy-first
            TelemetryKit::builder()
                .service_name("my-app")?
                .strict_privacy()
                .build()?
        }
    };
 
    // Your application logic
    telemetry.shutdown().await?;
    Ok(())
}
 
fn detect_user_location() -> &'static str {
    // Implement location detection
    // This is a simplified example
    "EU"
}
 
fn show_ccpa_notice() {
    println!("CCPA Notice of Data Collection...");
}

let telemetry = TelemetryKit::builder()
    .service_name("my-app")?
    .endpoint("https://telemetry.yourcompany.com")?  // Your server
    .token("token")?
    .secret("secret")?
    .build()?;

// Log consent events
telemetry.track_event("consent_change", |event| {
    event
        .property("status", "granted")
        .property("timestamp", chrono::Utc::now().to_rfc3339())
}).await?;

# Check data retention
telemetry-kit events list --older-than 30
 
# Verify consent status
telemetry-kit consent status
 
# Export for audit
telemetry-kit events export --format json > audit-$(date +%Y%m%d).json

## Privacy
 
This application respects your privacy:
 
- ✅ **Anonymous by default** - All data is anonymized
- ✅ **DO_NOT_TRACK support** - Set `DO_NOT_TRACK=1` to disable
- ✅ **Local-first** - Data stored locally, sync is optional
- ✅ **GDPR compliant** - Consent-based, 30-day retention
- ✅ **Your data, your control** - Export or delete anytime
 
### Opt Out
bash
export DO_NOT_TRACK=1
 
### Manage Consent
bash
telemetry-kit consent status  # Check current status
telemetry-kit consent deny    # Disable telemetry
telemetry-kit consent grant   # Enable telemetry
 
### Access Your Data
bash
telemetry-kit events export --format json > my-data.json
 
### Delete Your Data
bash
telemetry-kit events clear
 
For privacy inquiries: privacy@example.com

// ❌ BAD: Default to "yes"
Confirm::new()
    .with_prompt("Enable telemetry?")
    .default(true)  // ❌ Not GDPR compliant
    .interact()?;
 
// ✅ GOOD: Default to "no"
Confirm::new()
    .with_prompt("Enable telemetry?")
    .default(false)  // ✅ GDPR compliant
    .interact()?;

// ❌ BAD: Track before consent
telemetry.track_event("app_start", |e| e.success(true)).await?;
let consent = prompt_for_consent()?;
 
// ✅ GOOD: Get consent first
let consent = prompt_for_consent()?;
if consent {
    telemetry.track_event("app_start", |e| e.success(true)).await?;
}

// ❌ BAD: Keep forever
.data_retention(0)  // ❌ Not GDPR compliant
 
// ✅ GOOD: Limited retention
.data_retention(30)  // ✅ GDPR compliant

// ❌ BAD: Ignore DO_NOT_TRACK
let telemetry = TelemetryKit::builder()
    .service_name("my-app")?
    .build()?;
 
// ✅ GOOD: Check DO_NOT_TRACK
if TelemetryKit::is_do_not_track_enabled() {
    return Ok(());  // Exit early
}
let telemetry = TelemetryKit::builder()
    .service_name("my-app")?
    .build()?;

#[cfg(test)]
mod privacy_tests {
    use super::*;
 
    #[tokio::test]
    async fn test_respects_do_not_track() {
        std::env::set_var("DO_NOT_TRACK", "1");
        assert!(TelemetryKit::is_do_not_track_enabled());
        std::env::remove_var("DO_NOT_TRACK");
    }
 
    #[tokio::test]
    async fn test_consent_required() {
        let telemetry = TelemetryKit::builder()
            .service_name("test")?
            .consent_required(true)
            .build()?;
 
        // Events should be ignored without consent
        telemetry.track_event("test", |e| e.success(true)).await?;
 
        let events = telemetry.export_events().await?;
        assert_eq!(events.len(), 0); // No events tracked
    }
 
    #[tokio::test]
    async fn test_data_sanitization() {
        let path = "/Users/john/secret.txt";
        let sanitized = PrivacyManager::sanitize_path(path);
        assert!(!sanitized.contains("john"));
    }
}