Skip to content

Commit d9fc764

Browse files
lcianlcian
committed
lints
1 parent 6e8b7da commit d9fc764

File tree

3 files changed

+144
-157
lines changed

3 files changed

+144
-157
lines changed

‎sentry/src/transports/curl.rs‎

Lines changed: 81 additions & 85 deletions
Original file line numberDiff line numberDiff line change
@@ -38,100 +38,96 @@ impl CurlHttpTransport {
3838
let accept_invalid_certs = options.accept_invalid_certs;
3939

4040
let mut handle = client;
41-
let thread = TransportThread::new(
42-
options,
43-
move |envelope, rl| {
44-
handle.reset();
45-
handle.url(&url).unwrap();
46-
handle.custom_request("POST").unwrap();
47-
48-
if accept_invalid_certs {
49-
handle.ssl_verify_host(false).unwrap();
50-
handle.ssl_verify_peer(false).unwrap();
51-
}
52-
53-
match (scheme, &http_proxy, &https_proxy) {
54-
(Scheme::Https, _, Some(proxy)) => {
55-
if let Err(err) = handle.proxy(proxy) {
56-
sentry_debug!("invalid proxy: {:?}", err);
57-
}
41+
let thread = TransportThread::new(options, move |envelope, rl| {
42+
handle.reset();
43+
handle.url(&url).unwrap();
44+
handle.custom_request("POST").unwrap();
45+
46+
if accept_invalid_certs {
47+
handle.ssl_verify_host(false).unwrap();
48+
handle.ssl_verify_peer(false).unwrap();
49+
}
50+
51+
match (scheme, &http_proxy, &https_proxy) {
52+
(Scheme::Https, _, Some(proxy)) => {
53+
if let Err(err) = handle.proxy(proxy) {
54+
sentry_debug!("invalid proxy: {:?}", err);
5855
}
59-
(_, Some(proxy), _) => {
60-
if let Err(err) = handle.proxy(proxy) {
61-
sentry_debug!("invalid proxy: {:?}", err);
62-
}
56+
}
57+
(_, Some(proxy), _) => {
58+
if let Err(err) = handle.proxy(proxy) {
59+
sentry_debug!("invalid proxy: {:?}", err);
6360
}
64-
_ => {}
6561
}
66-
67-
let mut body = Vec::new();
68-
envelope.to_writer(&mut body).unwrap();
69-
let mut body = Cursor::new(body);
70-
71-
let mut retry_after = None;
72-
let mut sentry_header = None;
73-
let mut headers = curl::easy::List::new();
74-
headers.append(&format!("X-Sentry-Auth: {auth}")).unwrap();
75-
headers.append("Expect:").unwrap();
76-
handle.http_headers(headers).unwrap();
77-
handle.upload(true).unwrap();
78-
handle.in_filesize(body.get_ref().len() as u64).unwrap();
79-
handle
80-
.read_function(move |buf| Ok(body.read(buf).unwrap_or(0)))
81-
.unwrap();
82-
handle.verbose(true).unwrap();
62+
_ => {}
63+
}
64+
65+
let mut body = Vec::new();
66+
envelope.to_writer(&mut body).unwrap();
67+
let mut body = Cursor::new(body);
68+
69+
let mut retry_after = None;
70+
let mut sentry_header = None;
71+
let mut headers = curl::easy::List::new();
72+
headers.append(&format!("X-Sentry-Auth: {auth}")).unwrap();
73+
headers.append("Expect:").unwrap();
74+
handle.http_headers(headers).unwrap();
75+
handle.upload(true).unwrap();
76+
handle.in_filesize(body.get_ref().len() as u64).unwrap();
77+
handle
78+
.read_function(move |buf| Ok(body.read(buf).unwrap_or(0)))
79+
.unwrap();
80+
handle.verbose(true).unwrap();
81+
handle
82+
.debug_function(move |info, data| {
83+
let prefix = match info {
84+
curl::easy::InfoType::HeaderIn => "< ",
85+
curl::easy::InfoType::HeaderOut => "> ",
86+
curl::easy::InfoType::DataOut => "",
87+
_ => return,
88+
};
89+
sentry_debug!("curl: {}{}", prefix, String::from_utf8_lossy(data).trim());
90+
})
91+
.unwrap();
92+
93+
{
94+
let mut handle = handle.transfer();
95+
let retry_after_setter = &mut retry_after;
96+
let sentry_header_setter = &mut sentry_header;
8397
handle
84-
.debug_function(move |info, data| {
85-
let prefix = match info {
86-
curl::easy::InfoType::HeaderIn => "< ",
87-
curl::easy::InfoType::HeaderOut => "> ",
88-
curl::easy::InfoType::DataOut => "",
89-
_ => return,
90-
};
91-
sentry_debug!("curl: {}{}", prefix, String::from_utf8_lossy(data).trim());
92-
})
93-
.unwrap();
94-
95-
{
96-
let mut handle = handle.transfer();
97-
let retry_after_setter = &mut retry_after;
98-
let sentry_header_setter = &mut sentry_header;
99-
handle
100-
.header_function(move |data| {
101-
if let Ok(data) = std::str::from_utf8(data) {
102-
let mut iter = data.split(':');
103-
if let Some(key) = iter.next().map(str::to_lowercase) {
104-
if key == "retry-after" {
105-
*retry_after_setter =
106-
iter.next().map(|x| x.trim().to_string());
107-
} else if key == "x-sentry-rate-limits" {
108-
*sentry_header_setter =
109-
iter.next().map(|x| x.trim().to_string());
110-
}
98+
.header_function(move |data| {
99+
if let Ok(data) = std::str::from_utf8(data) {
100+
let mut iter = data.split(':');
101+
if let Some(key) = iter.next().map(str::to_lowercase) {
102+
if key == "retry-after" {
103+
*retry_after_setter = iter.next().map(|x| x.trim().to_string());
104+
} else if key == "x-sentry-rate-limits" {
105+
*sentry_header_setter =
106+
iter.next().map(|x| x.trim().to_string());
111107
}
112108
}
113-
true
114-
})
115-
.unwrap();
116-
handle.perform().ok();
117-
}
118-
119-
match handle.response_code() {
120-
Ok(response_code) => {
121-
if let Some(sentry_header) = sentry_header {
122-
rl.update_from_sentry_header(&sentry_header);
123-
} else if let Some(retry_after) = retry_after {
124-
rl.update_from_retry_after(&retry_after);
125-
} else if response_code == 429 {
126-
rl.update_from_429();
127109
}
110+
true
111+
})
112+
.unwrap();
113+
handle.perform().ok();
114+
}
115+
116+
match handle.response_code() {
117+
Ok(response_code) => {
118+
if let Some(sentry_header) = sentry_header {
119+
rl.update_from_sentry_header(&sentry_header);
120+
} else if let Some(retry_after) = retry_after {
121+
rl.update_from_retry_after(&retry_after);
122+
} else if response_code == 429 {
123+
rl.update_from_429();
128124
}
129-
Err(err) => {
130-
sentry_debug!("Failed to send envelope: {}", err);
131-
}
132125
}
133-
},
134-
);
126+
Err(err) => {
127+
sentry_debug!("Failed to send envelope: {}", err);
128+
}
129+
}
130+
});
135131
Self { thread }
136132
}
137133
}

‎sentry/src/transports/reqwest.rs‎

Lines changed: 35 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -62,51 +62,48 @@ impl ReqwestHttpTransport {
6262
let auth = dsn.to_auth(Some(&user_agent)).to_string();
6363
let url = dsn.envelope_api_url().to_string();
6464

65-
let thread = TransportThread::new(
66-
options,
67-
move |envelope, mut rl| {
68-
let mut body = Vec::new();
69-
envelope.to_writer(&mut body).unwrap();
70-
let request = client.post(&url).header("X-Sentry-Auth", &auth).body(body);
65+
let thread = TransportThread::new(options, move |envelope, mut rl| {
66+
let mut body = Vec::new();
67+
envelope.to_writer(&mut body).unwrap();
68+
let request = client.post(&url).header("X-Sentry-Auth", &auth).body(body);
7169

72-
// NOTE: because of lifetime issues, building the request using the
73-
// `client` has to happen outside of this async block.
74-
async move {
75-
match request.send().await {
76-
Ok(response) => {
77-
let headers = response.headers();
70+
// NOTE: because of lifetime issues, building the request using the
71+
// `client` has to happen outside of this async block.
72+
async move {
73+
match request.send().await {
74+
Ok(response) => {
75+
let headers = response.headers();
7876

79-
if let Some(sentry_header) = headers
80-
.get("x-sentry-rate-limits")
81-
.and_then(|x| x.to_str().ok())
82-
{
83-
rl.update_from_sentry_header(sentry_header);
84-
} else if let Some(retry_after) = headers
85-
.get(ReqwestHeaders::RETRY_AFTER)
86-
.and_then(|x| x.to_str().ok())
87-
{
88-
rl.update_from_retry_after(retry_after);
89-
} else if response.status() == StatusCode::TOO_MANY_REQUESTS {
90-
rl.update_from_429();
91-
}
77+
if let Some(sentry_header) = headers
78+
.get("x-sentry-rate-limits")
79+
.and_then(|x| x.to_str().ok())
80+
{
81+
rl.update_from_sentry_header(sentry_header);
82+
} else if let Some(retry_after) = headers
83+
.get(ReqwestHeaders::RETRY_AFTER)
84+
.and_then(|x| x.to_str().ok())
85+
{
86+
rl.update_from_retry_after(retry_after);
87+
} else if response.status() == StatusCode::TOO_MANY_REQUESTS {
88+
rl.update_from_429();
89+
}
9290

93-
match response.text().await {
94-
Err(err) => {
95-
sentry_debug!("Failed to read sentry response: {}", err);
96-
}
97-
Ok(text) => {
98-
sentry_debug!("Get response: `{}`", text);
99-
}
91+
match response.text().await {
92+
Err(err) => {
93+
sentry_debug!("Failed to read sentry response: {}", err);
94+
}
95+
Ok(text) => {
96+
sentry_debug!("Get response: `{}`", text);
10097
}
101-
}
102-
Err(err) => {
103-
sentry_debug!("Failed to send envelope: {}", err);
10498
}
10599
}
106-
rl
100+
Err(err) => {
101+
sentry_debug!("Failed to send envelope: {}", err);
102+
}
107103
}
108-
},
109-
);
104+
rl
105+
}
106+
});
110107
Self { thread }
111108
}
112109
}

‎sentry/src/transports/ureq.rs‎

Lines changed: 28 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -83,45 +83,39 @@ impl UreqHttpTransport {
8383
let auth = dsn.to_auth(Some(&user_agent)).to_string();
8484
let url = dsn.envelope_api_url().to_string();
8585

86-
let thread = TransportThread::new(
87-
options,
88-
move |envelope, rl| {
89-
let mut body = Vec::new();
90-
envelope.to_writer(&mut body).unwrap();
91-
let request = agent.post(&url).header("X-Sentry-Auth", &auth).send(&body);
92-
93-
match request {
94-
Ok(mut response) => {
95-
fn header_str<'a, B>(
96-
response: &'a Response<B>,
97-
key: &str,
98-
) -> Option<&'a str> {
99-
response.headers().get(key)?.to_str().ok()
100-
}
86+
let thread = TransportThread::new(options, move |envelope, rl| {
87+
let mut body = Vec::new();
88+
envelope.to_writer(&mut body).unwrap();
89+
let request = agent.post(&url).header("X-Sentry-Auth", &auth).send(&body);
90+
91+
match request {
92+
Ok(mut response) => {
93+
fn header_str<'a, B>(response: &'a Response<B>, key: &str) -> Option<&'a str> {
94+
response.headers().get(key)?.to_str().ok()
95+
}
10196

102-
if let Some(sentry_header) = header_str(&response, "x-sentry-rate-limits") {
103-
rl.update_from_sentry_header(sentry_header);
104-
} else if let Some(retry_after) = header_str(&response, "retry-after") {
105-
rl.update_from_retry_after(retry_after);
106-
} else if response.status() == 429 {
107-
rl.update_from_429();
108-
}
97+
if let Some(sentry_header) = header_str(&response, "x-sentry-rate-limits") {
98+
rl.update_from_sentry_header(sentry_header);
99+
} else if let Some(retry_after) = header_str(&response, "retry-after") {
100+
rl.update_from_retry_after(retry_after);
101+
} else if response.status() == 429 {
102+
rl.update_from_429();
103+
}
109104

110-
match response.body_mut().read_to_string() {
111-
Err(err) => {
112-
sentry_debug!("Failed to read sentry response: {}", err);
113-
}
114-
Ok(text) => {
115-
sentry_debug!("Get response: `{}`", text);
116-
}
105+
match response.body_mut().read_to_string() {
106+
Err(err) => {
107+
sentry_debug!("Failed to read sentry response: {}", err);
108+
}
109+
Ok(text) => {
110+
sentry_debug!("Get response: `{}`", text);
117111
}
118112
}
119-
Err(err) => {
120-
sentry_debug!("Failed to send envelope: {}", err);
121-
}
122113
}
123-
},
124-
);
114+
Err(err) => {
115+
sentry_debug!("Failed to send envelope: {}", err);
116+
}
117+
}
118+
});
125119
Self { thread }
126120
}
127121
}

0 commit comments

Comments
 (0)