feat: Added support for disabled clients

Author: mitsuhiko

src/client/real.rs

@@ -29,15 +29,14 @@ use constants::{SDK_INFO, USER_AGENT};
 /// [the shim client docs](shim/struct.Client.html).
 #[derive(Clone)]
 pub struct Client {
-    dsn: Dsn,
     options: ClientOptions,
-    transport: Arc<Transport>,
+    transport: Option<Arc<Transport>>,
 }
 
 impl fmt::Debug for Client {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("Client")
-            .field("dsn", &self.dsn)
+            .field("dsn", &self.dsn())
             .field("options", &self.options)
             .finish()
     }
@@ -225,11 +224,25 @@ impl Client {
 
     /// Creates a new sentry client for the given DSN.
     pub fn with_dsn_and_options(dsn: Dsn, options: ClientOptions) -> Client {
-        let transport = Transport::new(&dsn, options.user_agent.to_string());
+        let transport = Transport::new(dsn, options.user_agent.to_string());
         Client {
-            dsn: dsn,
             options: options,
-            transport: Arc::new(transport),
+            transport: Some(Arc::new(transport))
+        }
+    }
+
+    /// Creates a new client that does not send anything.
+    ///
+    /// This is useful when general sentry handling is wanted but a client cannot be bound
+    /// yet as the DSN might not be available yet.  In that case a disabled client can be
+    /// bound and later replaced by another one.
+    ///
+    /// A disabled client can be detected by inspecting the DSN.  If the DSN is `None` then
+    /// the client is disabled.
+    pub fn disabled() -> Client {
+        Client {
+            options: Default::default(),
+            transport: None,
         }
     }
 
@@ -400,14 +413,20 @@ impl Client {
     }
 
     /// Returns the DSN that constructed this client.
-    pub fn dsn(&self) -> &Dsn {
-        &self.dsn
+    ///
+    /// If the client is in disabled mode this returns `None`.
+    pub fn dsn(&self) -> Option<&Dsn> {
+        self.transport.as_ref().map(|x| x.dsn())
     }
 
     /// Captures an event and sends it to sentry.
     pub fn capture_event(&self, mut event: Event<'static>, scope: Option<&Scope>) -> Uuid {
-        self.prepare_event(&mut event, scope);
-        self.transport.send_event(event)
+        if let Some(ref transport) = self.transport {
+            self.prepare_event(&mut event, scope);
+            transport.send_event(event)
+        } else {
+            Default::default()
+        }
     }
 
     /// Drains all pending events up to the current time.
@@ -416,7 +435,11 @@ impl Client {
     /// given time or `false` if not (for instance because of a timeout).
     /// If no timeout is provided the client will wait forever.
     pub fn drain_events(&self, timeout: Option<Duration>) -> bool {
-        self.transport.drain(timeout)
+        if let Some(ref transport) = self.transport {
+            transport.drain(timeout)
+        } else {
+            true
+        }
     }
 }
 

src/transport.rs

@@ -13,6 +13,7 @@ use protocol::Event;
 /// A transport can send rust events.
 #[derive(Debug)]
 pub struct Transport {
+    dsn: Dsn,
     sender: Mutex<SyncSender<Option<Event<'static>>>>,
     drain_signal: Arc<Condvar>,
     queue_size: Arc<Mutex<usize>>,
@@ -81,7 +82,7 @@ fn spawn_http_sender(
 
 impl Transport {
     /// Creates a new client.
-    pub fn new(dsn: &Dsn, user_agent: String) -> Transport {
+    pub fn new(dsn: Dsn, user_agent: String) -> Transport {
         let (sender, receiver) = sync_channel(30);
         let drain_signal = Arc::new(Condvar::new());
         let queue_size = Arc::new(Mutex::new(0));
@@ -93,6 +94,7 @@ impl Transport {
             user_agent,
         ));
         Transport {
+            dsn: dsn,
             sender: Mutex::new(sender),
             drain_signal: drain_signal,
             queue_size: queue_size,
@@ -118,6 +120,11 @@ impl Transport {
         event_id
     }
 
+    /// Returns the dsn of the transport
+    pub fn dsn(&self) -> &Dsn {
+        &self.dsn
+    }
+
     /// Drains remaining messages in the transport.
     ///
     /// This returns `true` if the queue was successfully drained in the