feat: 2018 edition fixes and various cleanups. (#116)

Author: mitsuhiko

.travis.yml

@@ -18,9 +18,9 @@ matrix:
     - env: SUITE=format-check
     - env: SUITE=lint
     - env: SUITE=check
-      rust: "1.30.0"
+      rust: "1.31.0"
     - env: SUITE=cargotest
-      rust: "1.30.0"
+      rust: "1.31.0"
     - env: SUITE=checkall
     - env: SUITE=cargotestall
     - os: osx
@@ -29,10 +29,6 @@ matrix:
       env: SUITE=cargotestall
     - env: SUITE=travis-push-docs
 
-  allow_failures:
-    - env: SUITE=format-check
-    - env: SUITE=lint
-
 notifications:
   webhooks:
     urls:

Cargo.toml

@@ -11,6 +11,7 @@ description = """
 Sentry (getsentry.com) client for rust ;)
 """
 build = "build.rs"
+autoexamples = true
 
 [package.metadata.docs.rs]
 all-features = true
@@ -67,25 +68,5 @@ actix-web = { version = "0.7.17", default-features = false }
 name = "error-chain-demo"
 required-features = ["with_error_chain"]
 
-# TODO: Remove these once autoexamples are stable
-[[example]]
-name = "failure-demo"
-[[example]]
-name = "log-demo"
-[[example]]
-name = "message-demo"
-[[example]]
-name = "panic-demo"
-[[example]]
-name = "thread-demo"
-[[example]]
-name = "init-with-client"
-[[example]]
-name = "event-processors"
-[[example]]
-name = "before-send"
-[[example]]
-name = "send-with-extra"
-
 [workspace]
 members = [".", "integrations/sentry-actix"]

Makefile

@@ -78,13 +78,13 @@ test: checkall cargotestall
 .PHONY: test
 
 format-check:
-	@rustup component add rustfmt-preview 2> /dev/null
+	@rustup component add rustfmt 2> /dev/null
 	@cargo fmt -- --check
 .PHONY: format-check
 
 lint:
-	@rustup component add clippy-preview 2> /dev/null
-	@cargo clippy --all-features --tests --all --examples -- -D clippy
+	@rustup component add clippy 2> /dev/null
+	@cargo clippy --all-features --tests --all --examples -- -D clippy::all
 .PHONY: lint
 
 travis-push-docs:

examples/log-demo.rs

@@ -1,9 +1,10 @@
-#[macro_use]
 extern crate log;
 extern crate pretty_env_logger;
-#[macro_use]
 extern crate sentry;
 
+use log::{debug, error, info, warn};
+use sentry::sentry_crate_release;
+
 fn main() {
     let _sentry = sentry::init((
         "https://[email protected]/1041156",

integrations/sentry-actix/README.md

@@ -18,12 +18,12 @@ We currently only verify this crate against a recent version of Sentry hosted on
 [sentry.io](https://sentry.io/) but it should work with on-prem Sentry versions
 8.20 and later.
 
-Additionally, the lowest Rust version we target is _1.24.0_.
+Additionally, the lowest Rust version we target is _1.31.0_.
 
 ## Resources
 
-* [crates.io](https://crates.io/crate/sentry)
-* [Documentation](https://docs.rs/sentry)
-* [Bug Tracker](https://github.com/getsentry/sentry-rust/issues)
-* [IRC](irc://chat.freenode.net/sentry) (chat.freenode.net, #sentry)
-* Follow [@getsentry](https://twitter.com/getsentry) on Twitter for updates
+- [crates.io](https://crates.io/crate/sentry)
+- [Documentation](https://docs.rs/sentry)
+- [Bug Tracker](https://github.com/getsentry/sentry-rust/issues)
+- [IRC](irc://chat.freenode.net/sentry) (chat.freenode.net, #sentry)
+- Follow [@getsentry](https://twitter.com/getsentry) on Twitter for updates

integrations/sentry-actix/src/lib.rs

@@ -79,16 +79,17 @@ extern crate failure;
 extern crate fragile;
 extern crate sentry;
 
+use std::borrow::Cow;
+use std::cell::RefCell;
+use std::sync::{Arc, Mutex};
+
 use actix_web::middleware::{Finished, Middleware, Response, Started};
 use actix_web::{Error, HttpMessage, HttpRequest, HttpResponse};
 use failure::Fail;
 use sentry::integrations::failure::exception_from_single_fail;
-use sentry::internals::ScopeGuard;
+use sentry::internals::{ScopeGuard, Uuid};
 use sentry::protocol::{ClientSdkPackage, Event, Level};
-use sentry::{Hub, Uuid};
-use std::borrow::Cow;
-use std::cell::RefCell;
-use std::sync::{Arc, Mutex};
+use sentry::Hub;
 
 /// A helper construct that can be used to reconfigure and build the middleware.
 pub struct SentryMiddlewareBuilder {

src/api.rs

@@ -1,35 +1,10 @@
-use api::protocol::Event;
-
-// public api from other crates
-pub use sentry_types::protocol::v7 as protocol;
-pub use sentry_types::protocol::v7::{Breadcrumb, Level, User};
-pub use sentry_types::{
-    ChronoParseError, DateTime, DebugId, Dsn, ParseDebugIdError, TimeZone, Utc, Uuid, UuidVariant,
-    UuidVersion,
-};
-
-// public exports from this crate
 #[cfg(feature = "with_client_implementation")]
-pub use client::{init, Client, ClientOptions};
-pub use hub::Hub;
-pub use scope::Scope;
+use crate::hub::Hub;
+use crate::scope::Scope;
 
-use hub::IntoBreadcrumbs;
-
-/// Useful internals.
-///
-/// This module contains types that users of the create typically do not
-/// have to directly interface with directly.  These are often returned
-/// from methods on other types.
-pub mod internals {
-    #[cfg(feature = "with_client_implementation")]
-    pub use client::{ClientInitGuard, IntoDsn};
-    pub use hub::IntoBreadcrumbs;
-    pub use scope::ScopeGuard;
-    pub use sentry_types::{Auth, DsnParseError, ProjectId, ProjectIdParseError, Scheme};
-    #[cfg(feature = "with_client_implementation")]
-    pub use transport::{DefaultTransportFactory, HttpTransport, Transport, TransportFactory};
-}
+use crate::hub::IntoBreadcrumbs;
+use crate::internals;
+use crate::protocol::{Event, Level};
 
 /// Captures an event on the currently active client if any.
 ///
@@ -50,7 +25,7 @@ pub mod internals {
 /// });
 /// ```
 #[allow(unused_variables)]
-pub fn capture_event(event: Event<'static>) -> Uuid {
+pub fn capture_event(event: Event<'static>) -> internals::Uuid {
     with_client_impl! {{
         Hub::with(|hub| hub.capture_event(event))
     }}
@@ -60,7 +35,7 @@ pub fn capture_event(event: Event<'static>) -> Uuid {
 ///
 /// This creates an event form the given message and sends it to the current hub.
 #[allow(unused_variables)]
-pub fn capture_message(msg: &str, level: Level) -> Uuid {
+pub fn capture_message(msg: &str, level: Level) -> internals::Uuid {
     with_client_impl! {{
         Hub::with_active(|hub| {
             hub.capture_message(msg, level)
@@ -189,7 +164,7 @@ where
 }
 
 /// Returns the last event ID captured.
-pub fn last_event_id() -> Option<Uuid> {
+pub fn last_event_id() -> Option<internals::Uuid> {
     with_client_impl! {{
         Hub::with_active(|hub| {
             hub.last_event_id()

src/backtrace_support.rs

@@ -3,7 +3,7 @@ use std::fmt;
 use backtrace::Backtrace;
 use regex::{Captures, Regex};
 
-use api::protocol::{Frame, Stacktrace};
+use crate::protocol::{Frame, Stacktrace};
 
 lazy_static! {
     static ref HASH_FUNC_RE: Regex = Regex::new(r#"(?x)

src/client.rs

@@ -1,5 +1,4 @@
 use std::borrow::Cow;
-use std::env;
 use std::ffi::{OsStr, OsString};
 use std::fmt;
 use std::panic::RefUnwindSafe;
@@ -10,15 +9,14 @@ use std::time::Duration;
 use rand::random;
 use regex::Regex;
 
-use api::protocol::{Breadcrumb, DebugMeta, Event};
-use api::{Dsn, Uuid};
-use backtrace_support::{function_starts_with, is_sys_function, trim_stacktrace};
-use constants::{SDK_INFO, USER_AGENT};
-use hub::Hub;
-use internals::DsnParseError;
-use scope::Scope;
-use transport::{DefaultTransportFactory, Transport, TransportFactory};
-use utils::{debug_images, server_name};
+use crate::backtrace_support::{function_starts_with, is_sys_function, trim_stacktrace};
+use crate::constants::{SDK_INFO, USER_AGENT};
+use crate::hub::Hub;
+use crate::internals::{Dsn, DsnParseError, Uuid};
+use crate::protocol::{Breadcrumb, DebugMeta, Event};
+use crate::scope::Scope;
+use crate::transport::{DefaultTransportFactory, Transport, TransportFactory};
+use crate::utils;
 
 /// The Sentry client object.
 pub struct Client {
@@ -175,7 +173,7 @@ impl Default for ClientOptions {
     fn default() -> ClientOptions {
         ClientOptions {
             // any invalid dsn including the empty string disables the dsn
-            dsn: env::var("SENTRY_DSN")
+            dsn: std::env::var("SENTRY_DSN")
                 .ok()
                 .and_then(|dsn| dsn.parse::<Dsn>().ok()),
             transport: Box::new(DefaultTransportFactory),
@@ -190,15 +188,15 @@ impl Default for ClientOptions {
             } else {
                 "release".into()
             }),
-            server_name: server_name().map(Cow::Owned),
+            server_name: utils::server_name().map(Cow::Owned),
             sample_rate: 1.0,
             user_agent: Cow::Borrowed(&USER_AGENT),
-            http_proxy: env::var("http_proxy").ok().map(Cow::Owned),
-            https_proxy: env::var("https_proxy")
+            http_proxy: std::env::var("http_proxy").ok().map(Cow::Owned),
+            https_proxy: std::env::var("https_proxy")
                 .ok()
                 .map(Cow::Owned)
-                .or_else(|| env::var("HTTPS_PROXY").ok().map(Cow::Owned))
-                .or_else(|| env::var("http_proxy").ok().map(Cow::Owned)),
+                .or_else(|| std::env::var("HTTPS_PROXY").ok().map(Cow::Owned))
+                .or_else(|| std::env::var("http_proxy").ok().map(Cow::Owned)),
             shutdown_timeout: Duration::from_secs(2),
             debug: false,
             attach_stacktrace: false,
@@ -352,11 +350,9 @@ impl Client {
     /// If the DSN on the options is set to `None` the client will be entirely
     /// disabled.
     pub fn with_options(options: ClientOptions) -> Client {
-        #[cfg_attr(feature = "cargo-clippy", allow(question_mark))]
-        let transport = RwLock::new(if options.dsn.is_none() {
-            None
-        } else {
-            Some(Arc::new(options.transport.create_transport(&options)))
+        let transport = RwLock::new(match options.dsn {
+            Some(_) => Some(Arc::new(options.transport.create_transport(&options))),
+            None => None,
         });
         Client { options, transport }
     }
@@ -383,15 +379,15 @@ impl Client {
         }
     }
 
-    #[cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity))]
+    #[allow(clippy::cyclomatic_complexity)]
     fn prepare_event(
         &self,
         mut event: Event<'static>,
         scope: Option<&Scope>,
     ) -> Option<Event<'static>> {
         lazy_static! {
             static ref DEBUG_META: DebugMeta = DebugMeta {
-                images: debug_images(),
+                images: utils::debug_images(),
                 ..Default::default()
             };
         }

src/constants.rs

@@ -1,4 +1,4 @@
-use api::protocol::{ClientSdkInfo, ClientSdkPackage};
+use crate::protocol::{ClientSdkInfo, ClientSdkPackage};
 
 /// The version of the library
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");

src/hub.rs

@@ -1,22 +1,18 @@
 #![allow(unused)]
 
 use std::cell::{Cell, UnsafeCell};
-use std::iter;
 use std::mem::drop;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex, RwLock, TryLockError};
 use std::thread;
 use std::time::Duration;
 
-use api::Uuid;
-#[cfg(feature = "with_client_implementation")]
-use client::Client;
-use protocol::{Breadcrumb, Event, Level};
-#[cfg(feature = "with_client_implementation")]
-use scope::Stack;
-use scope::{Scope, ScopeGuard};
+use crate::internals::Uuid;
+use crate::protocol::{Breadcrumb, Event, Level};
+use crate::scope::{Scope, ScopeGuard};
+
 #[cfg(feature = "with_client_implementation")]
-use utils::current_thread;
+use crate::{client::Client, scope::Stack, utils};
 
 #[cfg(feature = "with_client_implementation")]
 lazy_static! {
@@ -25,6 +21,7 @@ lazy_static! {
         thread::current().id()
     );
 }
+
 #[cfg(feature = "with_client_implementation")]
 thread_local! {
     static THREAD_HUB: UnsafeCell<Arc<Hub>> = UnsafeCell::new(
@@ -42,10 +39,10 @@ pub trait IntoBreadcrumbs {
 }
 
 impl IntoBreadcrumbs for Breadcrumb {
-    type Output = iter::Once<Breadcrumb>;
+    type Output = std::iter::Once<Breadcrumb>;
 
     fn into_breadcrumbs(self) -> Self::Output {
-        iter::once(self)
+        std::iter::once(self)
     }
 }
 
@@ -220,7 +217,7 @@ impl Hub {
 
     /// Binds a hub to the current thread for the duration of the call.
     #[cfg(feature = "with_client_implementation")]
-    #[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
+    #[allow(clippy::needless_pass_by_value)]
     pub fn run<F: FnOnce() -> R, R>(hub: Arc<Hub>, f: F) -> R {
         let mut restore_process_hub = false;
         let did_switch = THREAD_HUB.with(|ctx| unsafe {
@@ -300,7 +297,7 @@ impl Hub {
                         ..Default::default()
                     };
                     if client.options().attach_stacktrace {
-                        let thread = current_thread(true);
+                        let thread = utils::current_thread(true);
                         if thread.stacktrace.is_some() {
                             event.threads.values.push(thread);
                         }

src/integrations/env_logger.rs

@@ -23,9 +23,7 @@
 //! log_builder.parse("info,foo=debug");
 //! sentry::integrations::env_logger::init(Some(log_builder.build()), Default::default());
 //! ```
-use env_logger;
-
-use integrations::log::{self as sentry_log, LoggerOptions};
+use crate::integrations::log::{self as sentry_log, LoggerOptions};
 
 /// Initializes the environment logger.
 ///

src/integrations/error_chain.rs

@@ -28,10 +28,10 @@ use std::fmt::{Debug, Display};
 
 use error_chain::ChainedError;
 
-use api::protocol::{Event, Exception, Level};
-use api::Uuid;
-use backtrace_support::{backtrace_to_stacktrace, error_typename};
-use hub::Hub;
+use crate::backtrace_support::{backtrace_to_stacktrace, error_typename};
+use crate::hub::Hub;
+use crate::internals::Uuid;
+use crate::protocol::{Event, Exception, Level};
 
 fn exceptions_from_error_chain<T>(error: &T) -> Vec<Exception>
 where