/
surf.rs
102 lines (89 loc) · 3.55 KB
/
surf.rs
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
use std::time::Duration;
use isahc::{
config::{Configurable, SslOption},
HttpClient,
};
use surf::{http::headers as SurfHeaders, Client as SurfClient, StatusCode};
use super::tokio_thread::TransportThread;
use crate::{sentry_debug, ClientOptions, Envelope, Transport};
/// A [`Transport`] that sends events via the [`surf`] library.
///
/// This is enabled by the `surf` feature flag.
///
/// [`surf`]: https://crates.io/crates/surf
#[cfg_attr(doc_cfg, doc(cfg(feature = "surf")))]
pub struct SurfHttpTransport {
thread: TransportThread,
}
impl SurfHttpTransport {
/// Creates a new Transport.
pub fn new(options: &ClientOptions) -> Self {
Self::new_internal(options, None)
}
/// Creates a new Transport that uses the specified [`SurfClient`].
pub fn with_client(options: &ClientOptions, client: SurfClient) -> Self {
Self::new_internal(options, Some(client))
}
fn new_internal(options: &ClientOptions, client: Option<SurfClient>) -> Self {
let mut client = client.unwrap_or_else(SurfClient::new);
if options.accept_invalid_certs {
let hc = HttpClient::builder()
.ssl_options(SslOption::DANGER_ACCEPT_INVALID_CERTS)
.build()
.unwrap();
let http_client = http_client::isahc::IsahcClient::from_client(hc);
client = SurfClient::with_http_client(http_client)
}
let dsn = options.dsn.as_ref().unwrap();
let user_agent = options.user_agent.to_owned();
let auth = dsn.to_auth(Some(&user_agent)).to_string();
let url = dsn.envelope_api_url().to_string();
let thread = TransportThread::new(move |envelope, mut rl| {
let mut body = Vec::new();
envelope.to_writer(&mut body).unwrap();
let request = client.post(&url).header("X-Sentry-Auth", &auth).body(body);
async move {
match request.await {
Ok(mut response) => {
if let Some(sentry_header) =
response.header("x-sentry-rate-limits").map(|x| x.as_str())
{
rl.update_from_retry_after(sentry_header);
} else if let Some(retry_after) = response
.header(SurfHeaders::RETRY_AFTER)
.map(|x| x.as_str())
{
rl.update_from_retry_after(retry_after);
} else if response.status() == StatusCode::TooManyRequests {
rl.update_from_429();
}
match response.body_string().await {
Err(err) => {
sentry_debug!("Failed to read sentry response: {}", err);
}
Ok(text) => {
sentry_debug!("Get response: `{}`", text);
}
}
}
Err(err) => {
sentry_debug!("Failed to send envelope: {}", err);
}
}
rl
}
});
Self { thread }
}
}
impl Transport for SurfHttpTransport {
fn send_envelope(&self, envelope: Envelope) {
self.thread.send(envelope)
}
fn flush(&self, timeout: Duration) -> bool {
self.thread.flush(timeout)
}
fn shutdown(&self, timeout: Duration) -> bool {
self.flush(timeout)
}
}