runner_q 0.6.4

Durable activity queue and worker system
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use serde::{Deserialize, Serialize};

/// Configuration for the WorkerEngine that controls queue behavior and resource usage.
///
/// This struct contains all the necessary settings to configure how the worker engine
/// processes activities and manages concurrency. The storage backend is provided
/// separately via `WorkerEngine::builder().backend(...)`.
///
/// # Examples
///
/// ```rust
/// use runner_q::WorkerConfig;
///
/// let config = WorkerConfig {
///     queue_name: "my_app_queue".to_string(),
///     max_concurrent_activities: 5,
///     ..WorkerConfig::default()
/// };
/// ```
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WorkerConfig {
    /// The name of the queue to use for activities.
    ///
    /// This name is used as a prefix to avoid conflicts between different
    /// applications or environments (e.g. table/stream names in the backend).
    ///
    /// # Examples
    ///
    /// ```rust
    /// use runner_q::WorkerConfig;
    ///
    /// let config = WorkerConfig {
    ///     queue_name: "production_activities".to_string(),
    ///     // ... other fields
    ///     ..WorkerConfig::default()
    /// };
    /// ```
    pub queue_name: String,

    /// Maximum number of activities that can be processed concurrently.
    ///
    /// This controls the worker pool size and prevents resource exhaustion.
    /// Higher values allow more parallelism but consume more memory and CPU.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use runner_q::WorkerConfig;
    ///
    /// // Conservative setting for resource-constrained environments
    /// let config = WorkerConfig {
    ///     max_concurrent_activities: 2,
    ///     // ... other fields
    ///     ..WorkerConfig::default()
    /// };
    ///
    /// // High-throughput setting for powerful servers
    /// let config = WorkerConfig {
    ///     max_concurrent_activities: 50,
    ///     // ... other fields
    ///     ..WorkerConfig::default()
    /// };
    /// ```
    pub max_concurrent_activities: usize,

    /// Interval in seconds for polling scheduled activities.
    ///
    /// When `None`, uses a default interval of 30 seconds.
    /// Lower values provide more responsive scheduling but increase backend load.
    ///
    /// This setting only takes effect for backends that do **not** handle
    /// scheduling natively in `dequeue()`. The PostgreSQL backend handles
    /// scheduled activities directly in `dequeue()` and skips the polling loop.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use runner_q::WorkerConfig;
    ///
    /// // Check for scheduled activities every 10 seconds
    /// let config = WorkerConfig {
    ///     schedule_poll_interval_seconds: Some(10),
    ///     // ... other fields
    ///     ..WorkerConfig::default()
    /// };
    ///
    /// // Use default polling interval (30 seconds)
    /// let config = WorkerConfig {
    ///     schedule_poll_interval_seconds: None,
    ///     // ... other fields
    ///     ..WorkerConfig::default()
    /// };
    /// ```
    pub schedule_poll_interval_seconds: Option<u64>,

    /// Lease duration in milliseconds for claimed activities before considered expired
    /// Defaults to 60000 ms (60s)
    pub lease_ms: Option<u64>,

    /// Interval in seconds for the reaper to scan processing leases
    /// Defaults to 5 seconds
    pub reaper_interval_seconds: Option<u64>,

    /// Maximum number of expired items to requeue per reaper tick
    /// Defaults to 100
    pub reaper_batch_size: Option<usize>,

    /// Optional filter to restrict this engine to specific activity types.
    ///
    /// When `Some`, workers will only dequeue activities whose `activity_type`
    /// matches one of the listed values. When `None` (the default), workers
    /// dequeue all activity types (catch-all).
    pub activity_types: Option<Vec<String>>,
}

impl Default for WorkerConfig {
    fn default() -> Self {
        Self {
            queue_name: "default".to_string(),
            max_concurrent_activities: 10,
            schedule_poll_interval_seconds: None,
            lease_ms: Some(60_000),
            reaper_interval_seconds: Some(5),
            reaper_batch_size: Some(100),
            activity_types: None,
        }
    }
}