Skip to content

Commit 78c6ece

Browse files
tottototottoto
committed
chore: make tracing optional
1 parent 4617f49 commit 78c6ece

28 files changed

+361
-295
lines changed

‎.github/workflows/CI.yml

+3
Original file line numberDiff line numberDiff line change
@@ -51,6 +51,9 @@ jobs:
5151
- name: Check with unstable flag
5252
run: cargo check --features unstable
5353

54+
- name: Check with tracing feature
55+
run: cargo check --features tracing
56+
5457
- name: Run lib tests and doc tests
5558
run: cargo test
5659

‎Cargo.toml

+6-1
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,9 @@ rust-version = "1.63"
2323
# Enables `futures::Stream` implementations for various types.
2424
stream = []
2525

26+
# Enables tracing.
27+
tracing = ["dep:tracing"]
28+
2629
# Enables **unstable** APIs. Any API exposed by this feature has no backwards
2730
# compatibility guarantees. In other words, you should not use this feature for
2831
# anything besides experimentation. Definitely **do not** publish a crate that
@@ -46,12 +49,14 @@ tokio-util = { version = "0.7.1", features = ["codec", "io"] }
4649
tokio = { version = "1", features = ["io-util"] }
4750
bytes = "1"
4851
http = "1"
49-
tracing = { version = "0.1.35", default-features = false, features = ["std"] }
52+
tracing = { version = "0.1.35", default-features = false, features = ["std"], optional = true }
5053
fnv = "1.0.5"
5154
slab = "0.4.2"
5255
indexmap = { version = "2", features = ["std"] }
5356

5457
[dev-dependencies]
58+
# Test
59+
tracing = { version = "0.1.35", default-features = false, features = ["std"] }
5560

5661
# Fuzzing
5762
quickcheck = { version = "1.0.3", default-features = false }

‎src/client.rs

+13-7
Original file line numberDiff line numberDiff line change
@@ -141,6 +141,8 @@ use crate::frame::{Headers, Pseudo, Reason, Settings, StreamId};
141141
use crate::proto::{self, Error};
142142
use crate::{FlowControl, PingPong, RecvStream, SendStream};
143143

144+
#[cfg(feature = "tracing")]
145+
use ::tracing::Instrument;
144146
use bytes::{Buf, Bytes};
145147
use http::{uri, HeaderMap, Method, Request, Response, Version};
146148
use std::fmt;
@@ -150,7 +152,6 @@ use std::task::{Context, Poll};
150152
use std::time::Duration;
151153
use std::usize;
152154
use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt};
153-
use tracing::Instrument;
154155

155156
/// Initializes new HTTP/2 streams on a connection by sending a request.
156157
///
@@ -1276,10 +1277,15 @@ where
12761277
T: AsyncRead + AsyncWrite + Unpin,
12771278
{
12781279
let builder = Builder::new();
1279-
builder
1280+
1281+
#[cfg(feature = "tracing")]
1282+
return builder
12801283
.handshake(io)
1281-
.instrument(tracing::trace_span!("client_handshake"))
1282-
.await
1284+
.instrument(::tracing::trace_span!("client_handshake"))
1285+
.await;
1286+
1287+
#[cfg(not(feature = "tracing"))]
1288+
return builder.handshake(io).await;
12831289
}
12841290

12851291
// ===== impl Connection =====
@@ -1288,12 +1294,12 @@ async fn bind_connection<T>(io: &mut T) -> Result<(), crate::Error>
12881294
where
12891295
T: AsyncRead + AsyncWrite + Unpin,
12901296
{
1291-
tracing::debug!("binding client connection");
1297+
debug!("binding client connection");
12921298

12931299
let msg: &'static [u8] = b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n";
12941300
io.write_all(msg).await.map_err(crate::Error::from_io)?;
12951301

1296-
tracing::debug!("client connection bound");
1302+
debug!("client connection bound");
12971303

12981304
Ok(())
12991305
}
@@ -1440,7 +1446,7 @@ where
14401446
self.inner.maybe_close_connection_if_no_streams();
14411447
let result = self.inner.poll(cx).map_err(Into::into);
14421448
if result.is_pending() && !self.inner.has_streams_or_other_references() {
1443-
tracing::trace!("last stream closed during poll, wake again");
1449+
trace!("last stream closed during poll, wake again");
14441450
cx.waker().wake_by_ref();
14451451
}
14461452
result

‎src/codec/framed_read.rs

+29-31
Original file line numberDiff line numberDiff line change
@@ -126,10 +126,9 @@ fn decode_frame(
126126
partial_inout: &mut Option<Partial>,
127127
mut bytes: BytesMut,
128128
) -> Result<Option<Frame>, Error> {
129-
let span = tracing::trace_span!("FramedRead::decode_frame", offset = bytes.len());
130-
let _e = span.enter();
129+
let _span = trace_span!("FramedRead::decode_frame", offset = bytes.len());
131130

132-
tracing::trace!("decoding frame from {}B", bytes.len());
131+
trace!("decoding frame from {}B", bytes.len());
133132

134133
// Parse the head
135134
let head = frame::Head::parse(&bytes);
@@ -141,7 +140,7 @@ fn decode_frame(
141140

142141
let kind = head.kind();
143142

144-
tracing::trace!(frame.kind = ?kind);
143+
trace!(frame.kind = ?kind);
145144

146145
macro_rules! header_block {
147146
($frame:ident, $head:ident, $bytes:ident) => ({
@@ -159,8 +158,8 @@ fn decode_frame(
159158
// `PROTOCOL_ERROR`.
160159
return Err(Error::library_reset($head.stream_id(), Reason::PROTOCOL_ERROR));
161160
},
162-
Err(e) => {
163-
proto_err!(conn: "failed to load frame; err={:?}", e);
161+
Err(_e) => {
162+
proto_err!(conn: "failed to load frame; err={:?}", _e);
164163
return Err(Error::library_go_away(Reason::PROTOCOL_ERROR));
165164
}
166165
};
@@ -176,16 +175,16 @@ fn decode_frame(
176175
proto_err!(stream: "malformed header block; stream={:?}", id);
177176
return Err(Error::library_reset(id, Reason::PROTOCOL_ERROR));
178177
},
179-
Err(e) => {
180-
proto_err!(conn: "failed HPACK decoding; err={:?}", e);
178+
Err(_e) => {
179+
proto_err!(conn: "failed HPACK decoding; err={:?}", _e);
181180
return Err(Error::library_go_away(Reason::PROTOCOL_ERROR));
182181
}
183182
}
184183

185184
if is_end_headers {
186185
frame.into()
187186
} else {
188-
tracing::trace!("loaded partial header block");
187+
trace!("loaded partial header block");
189188
// Defer returning the frame
190189
*partial_inout = Some(Partial {
191190
frame: Continuable::$frame(frame),
@@ -202,26 +201,26 @@ fn decode_frame(
202201
Kind::Settings => {
203202
let res = frame::Settings::load(head, &bytes[frame::HEADER_LEN..]);
204203

205-
res.map_err(|e| {
206-
proto_err!(conn: "failed to load SETTINGS frame; err={:?}", e);
204+
res.map_err(|_e| {
205+
proto_err!(conn: "failed to load SETTINGS frame; err={:?}", _e);
207206
Error::library_go_away(Reason::PROTOCOL_ERROR)
208207
})?
209208
.into()
210209
}
211210
Kind::Ping => {
212211
let res = frame::Ping::load(head, &bytes[frame::HEADER_LEN..]);
213212

214-
res.map_err(|e| {
215-
proto_err!(conn: "failed to load PING frame; err={:?}", e);
213+
res.map_err(|_e| {
214+
proto_err!(conn: "failed to load PING frame; err={:?}", _e);
216215
Error::library_go_away(Reason::PROTOCOL_ERROR)
217216
})?
218217
.into()
219218
}
220219
Kind::WindowUpdate => {
221220
let res = frame::WindowUpdate::load(head, &bytes[frame::HEADER_LEN..]);
222221

223-
res.map_err(|e| {
224-
proto_err!(conn: "failed to load WINDOW_UPDATE frame; err={:?}", e);
222+
res.map_err(|_e| {
223+
proto_err!(conn: "failed to load WINDOW_UPDATE frame; err={:?}", _e);
225224
Error::library_go_away(Reason::PROTOCOL_ERROR)
226225
})?
227226
.into()
@@ -231,25 +230,25 @@ fn decode_frame(
231230
let res = frame::Data::load(head, bytes.freeze());
232231

233232
// TODO: Should this always be connection level? Probably not...
234-
res.map_err(|e| {
235-
proto_err!(conn: "failed to load DATA frame; err={:?}", e);
233+
res.map_err(|_e| {
234+
proto_err!(conn: "failed to load DATA frame; err={:?}", _e);
236235
Error::library_go_away(Reason::PROTOCOL_ERROR)
237236
})?
238237
.into()
239238
}
240239
Kind::Headers => header_block!(Headers, head, bytes),
241240
Kind::Reset => {
242241
let res = frame::Reset::load(head, &bytes[frame::HEADER_LEN..]);
243-
res.map_err(|e| {
244-
proto_err!(conn: "failed to load RESET frame; err={:?}", e);
242+
res.map_err(|_e| {
243+
proto_err!(conn: "failed to load RESET frame; err={:?}", _e);
245244
Error::library_go_away(Reason::PROTOCOL_ERROR)
246245
})?
247246
.into()
248247
}
249248
Kind::GoAway => {
250249
let res = frame::GoAway::load(&bytes[frame::HEADER_LEN..]);
251-
res.map_err(|e| {
252-
proto_err!(conn: "failed to load GO_AWAY frame; err={:?}", e);
250+
res.map_err(|_e| {
251+
proto_err!(conn: "failed to load GO_AWAY frame; err={:?}", _e);
253252
Error::library_go_away(Reason::PROTOCOL_ERROR)
254253
})?
255254
.into()
@@ -272,8 +271,8 @@ fn decode_frame(
272271
proto_err!(stream: "PRIORITY invalid dependency ID; stream={:?}", id);
273272
return Err(Error::library_reset(id, Reason::PROTOCOL_ERROR));
274273
}
275-
Err(e) => {
276-
proto_err!(conn: "failed to load PRIORITY frame; err={:?};", e);
274+
Err(_e) => {
275+
proto_err!(conn: "failed to load PRIORITY frame; err={:?};", _e);
277276
return Err(Error::library_go_away(Reason::PROTOCOL_ERROR));
278277
}
279278
}
@@ -301,7 +300,7 @@ fn decode_frame(
301300
} else {
302301
let cnt = partial.continuation_frames_count + 1;
303302
if cnt > max_continuation_frames {
304-
tracing::debug!("too_many_continuations, max = {}", max_continuation_frames);
303+
debug!("too_many_continuations, max = {}", max_continuation_frames);
305304
return Err(Error::library_go_away_data(
306305
Reason::ENHANCE_YOUR_CALM,
307306
"too_many_continuations",
@@ -348,8 +347,8 @@ fn decode_frame(
348347
proto_err!(stream: "malformed CONTINUATION frame; stream={:?}", id);
349348
return Err(Error::library_reset(id, Reason::PROTOCOL_ERROR));
350349
}
351-
Err(e) => {
352-
proto_err!(conn: "failed HPACK decoding; err={:?}", e);
350+
Err(_e) => {
351+
proto_err!(conn: "failed HPACK decoding; err={:?}", _e);
353352
return Err(Error::library_go_away(Reason::PROTOCOL_ERROR));
354353
}
355354
}
@@ -377,17 +376,16 @@ where
377376
type Item = Result<Frame, Error>;
378377

379378
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
380-
let span = tracing::trace_span!("FramedRead::poll_next");
381-
let _e = span.enter();
379+
let _span = trace_span!("FramedRead::poll_next");
382380
loop {
383-
tracing::trace!("poll");
381+
trace!("poll");
384382
let bytes = match ready!(Pin::new(&mut self.inner).poll_next(cx)) {
385383
Some(Ok(bytes)) => bytes,
386384
Some(Err(e)) => return Poll::Ready(Some(Err(map_err(e)))),
387385
None => return Poll::Ready(None),
388386
};
389387

390-
tracing::trace!(read.bytes = bytes.len());
388+
trace!(read.bytes = bytes.len());
391389
let Self {
392390
ref mut hpack,
393391
max_header_list_size,
@@ -402,7 +400,7 @@ where
402400
partial,
403401
bytes,
404402
)? {
405-
tracing::debug!(?frame, "received");
403+
debug!(?frame, "received");
406404
return Poll::Ready(Some(Ok(frame)));
407405
}
408406
}

‎src/codec/framed_write.rs

+14-16
Original file line numberDiff line numberDiff line change
@@ -128,19 +128,18 @@ where
128128

129129
/// Flush buffered data to the wire
130130
pub fn flush(&mut self, cx: &mut Context) -> Poll<io::Result<()>> {
131-
let span = tracing::trace_span!("FramedWrite::flush");
132-
let _e = span.enter();
131+
let _span = trace_span!("FramedWrite::flush");
133132

134133
loop {
135134
while !self.encoder.is_empty() {
136135
match self.encoder.next {
137136
Some(Next::Data(ref mut frame)) => {
138-
tracing::trace!(queued_data_frame = true);
137+
trace!(queued_data_frame = true);
139138
let mut buf = (&mut self.encoder.buf).chain(frame.payload_mut());
140139
ready!(poll_write_buf(Pin::new(&mut self.inner), cx, &mut buf))?
141140
}
142141
_ => {
143-
tracing::trace!(queued_data_frame = false);
142+
trace!(queued_data_frame = false);
144143
ready!(poll_write_buf(
145144
Pin::new(&mut self.inner),
146145
cx,
@@ -156,7 +155,7 @@ where
156155
}
157156
}
158157

159-
tracing::trace!("flushing buffer");
158+
trace!("flushing buffer");
160159
// Flush the upstream
161160
ready!(Pin::new(&mut self.inner).poll_flush(cx))?;
162161

@@ -207,10 +206,9 @@ where
207206
fn buffer(&mut self, item: Frame<B>) -> Result<(), UserError> {
208207
// Ensure that we have enough capacity to accept the write.
209208
assert!(self.has_capacity());
210-
let span = tracing::trace_span!("FramedWrite::buffer", frame = ?item);
211-
let _e = span.enter();
209+
let _span = trace_span!("FramedWrite::buffer", frame = ?item);
212210

213-
tracing::debug!(frame = ?item, "send");
211+
debug!(frame = ?item, "send");
214212

215213
match item {
216214
Frame::Data(mut v) => {
@@ -259,31 +257,31 @@ where
259257
}
260258
Frame::Settings(v) => {
261259
v.encode(self.buf.get_mut());
262-
tracing::trace!(rem = self.buf.remaining(), "encoded settings");
260+
trace!(rem = self.buf.remaining(), "encoded settings");
263261
}
264262
Frame::GoAway(v) => {
265263
v.encode(self.buf.get_mut());
266-
tracing::trace!(rem = self.buf.remaining(), "encoded go_away");
264+
trace!(rem = self.buf.remaining(), "encoded go_away");
267265
}
268266
Frame::Ping(v) => {
269267
v.encode(self.buf.get_mut());
270-
tracing::trace!(rem = self.buf.remaining(), "encoded ping");
268+
trace!(rem = self.buf.remaining(), "encoded ping");
271269
}
272270
Frame::WindowUpdate(v) => {
273271
v.encode(self.buf.get_mut());
274-
tracing::trace!(rem = self.buf.remaining(), "encoded window_update");
272+
trace!(rem = self.buf.remaining(), "encoded window_update");
275273
}
276274

277275
Frame::Priority(_) => {
278276
/*
279-
v.encode(self.buf.get_mut());
280-
tracing::trace!("encoded priority; rem={:?}", self.buf.remaining());
281-
*/
277+
v.encode(self.buf.get_mut());
278+
trace!("encoded priority; rem={:?}", self.buf.remaining());
279+
*/
282280
unimplemented!();
283281
}
284282
Frame::Reset(v) => {
285283
v.encode(self.buf.get_mut());
286-
tracing::trace!(rem = self.buf.remaining(), "encoded reset");
284+
trace!(rem = self.buf.remaining(), "encoded reset");
287285
}
288286
}
289287

‎src/frame/go_away.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -57,7 +57,7 @@ impl GoAway {
5757
}
5858

5959
pub fn encode<B: BufMut>(&self, dst: &mut B) {
60-
tracing::trace!("encoding GO_AWAY; code={:?}", self.error_code);
60+
trace!("encoding GO_AWAY; code={:?}", self.error_code);
6161
let head = Head::new(Kind::GoAway, 0, StreamId::zero());
6262
head.encode(8 + self.debug_data.len(), dst);
6363
dst.put_u32(self.last_stream_id.into());

0 commit comments

Comments
 (0)