vendor/tracing-subscriber/tests/env_filter/main.rs

   1 #![cfg(feature = "env-filter")]
   2
   3 #[path = "../support.rs"]
   4 mod support;
   5 use self::support::*;
   6
   7 mod per_layer;
   8
   9 use tracing::{self, subscriber::with_default, Level};
  10 use tracing_subscriber::{
  11     filter::{EnvFilter, LevelFilter},
  12     prelude::*,
  13 };
  14
  15 #[test]
  16 fn level_filter_event() {
  17     let filter: EnvFilter = "info".parse().expect("filter should parse");
  18     let (subscriber, finished) = subscriber::mock()
  19         .event(event::mock().at_level(Level::INFO))
  20         .event(event::mock().at_level(Level::WARN))
  21         .event(event::mock().at_level(Level::ERROR))
  22         .done()
  23         .run_with_handle();
  24     let subscriber = subscriber.with(filter);
  25
  26     with_default(subscriber, || {
  27         tracing::trace!("this should be disabled");
  28         tracing::info!("this shouldn't be");
  29         tracing::debug!(target: "foo", "this should also be disabled");
  30         tracing::warn!(target: "foo", "this should be enabled");
  31         tracing::error!("this should be enabled too");
  32     });
  33
  34     finished.assert_finished();
  35 }
  36
  37 #[test]
  38 fn same_name_spans() {
  39     let filter: EnvFilter = "[foo{bar}]=trace,[foo{baz}]=trace"
  40         .parse()
  41         .expect("filter should parse");
  42     let (subscriber, finished) = subscriber::mock()
  43         .new_span(
  44             span::mock()
  45                 .named("foo")
  46                 .at_level(Level::TRACE)
  47                 .with_field(field::mock("bar")),
  48         )
  49         .new_span(
  50             span::mock()
  51                 .named("foo")
  52                 .at_level(Level::TRACE)
  53                 .with_field(field::mock("baz")),
  54         )
  55         .done()
  56         .run_with_handle();
  57     let subscriber = subscriber.with(filter);
  58     with_default(subscriber, || {
  59         tracing::trace_span!("foo", bar = 1);
  60         tracing::trace_span!("foo", baz = 1);
  61     });
  62
  63     finished.assert_finished();
  64 }
  65
  66 #[test]
  67 fn level_filter_event_with_target() {
  68     let filter: EnvFilter = "info,stuff=debug".parse().expect("filter should parse");
  69     let (subscriber, finished) = subscriber::mock()
  70         .event(event::mock().at_level(Level::INFO))
  71         .event(event::mock().at_level(Level::DEBUG).with_target("stuff"))
  72         .event(event::mock().at_level(Level::WARN).with_target("stuff"))
  73         .event(event::mock().at_level(Level::ERROR))
  74         .event(event::mock().at_level(Level::ERROR).with_target("stuff"))
  75         .done()
  76         .run_with_handle();
  77     let subscriber = subscriber.with(filter);
  78
  79     with_default(subscriber, || {
  80         tracing::trace!("this should be disabled");
  81         tracing::info!("this shouldn't be");
  82         tracing::debug!(target: "stuff", "this should be enabled");
  83         tracing::debug!("but this shouldn't");
  84         tracing::trace!(target: "stuff", "and neither should this");
  85         tracing::warn!(target: "stuff", "this should be enabled");
  86         tracing::error!("this should be enabled too");
  87         tracing::error!(target: "stuff", "this should be enabled also");
  88     });
  89
  90     finished.assert_finished();
  91 }
  92
  93 #[test]
  94 fn level_filter_event_with_target_and_span_global() {
  95     let filter: EnvFilter = "info,stuff[cool_span]=debug"
  96         .parse()
  97         .expect("filter should parse");
  98
  99     let cool_span = span::named("cool_span");
 100     let uncool_span = span::named("uncool_span");
 101     let (subscriber, handle) = subscriber::mock()
 102         .enter(cool_span.clone())
 103         .event(
 104             event::mock()
 105                 .at_level(Level::DEBUG)
 106                 .in_scope(vec![cool_span.clone()]),
 107         )
 108         .exit(cool_span)
 109         .enter(uncool_span.clone())
 110         .exit(uncool_span)
 111         .done()
 112         .run_with_handle();
 113
 114     let subscriber = subscriber.with(filter);
 115
 116     with_default(subscriber, || {
 117         {
 118             let _span = tracing::info_span!(target: "stuff", "cool_span").entered();
 119             tracing::debug!("this should be enabled");
 120         }
 121
 122         tracing::debug!("should also be disabled");
 123
 124         {
 125             let _span = tracing::info_span!("uncool_span").entered();
 126             tracing::debug!("this should be disabled");
 127         }
 128     });
 129
 130     handle.assert_finished();
 131 }
 132
 133 #[test]
 134 fn not_order_dependent() {
 135     // this test reproduces tokio-rs/tracing#623
 136
 137     let filter: EnvFilter = "stuff=debug,info".parse().expect("filter should parse");
 138     let (subscriber, finished) = subscriber::mock()
 139         .event(event::mock().at_level(Level::INFO))
 140         .event(event::mock().at_level(Level::DEBUG).with_target("stuff"))
 141         .event(event::mock().at_level(Level::WARN).with_target("stuff"))
 142         .event(event::mock().at_level(Level::ERROR))
 143         .event(event::mock().at_level(Level::ERROR).with_target("stuff"))
 144         .done()
 145         .run_with_handle();
 146     let subscriber = subscriber.with(filter);
 147
 148     with_default(subscriber, || {
 149         tracing::trace!("this should be disabled");
 150         tracing::info!("this shouldn't be");
 151         tracing::debug!(target: "stuff", "this should be enabled");
 152         tracing::debug!("but this shouldn't");
 153         tracing::trace!(target: "stuff", "and neither should this");
 154         tracing::warn!(target: "stuff", "this should be enabled");
 155         tracing::error!("this should be enabled too");
 156         tracing::error!(target: "stuff", "this should be enabled also");
 157     });
 158
 159     finished.assert_finished();
 160 }
 161
 162 #[test]
 163 fn add_directive_enables_event() {
 164     // this test reproduces tokio-rs/tracing#591
 165
 166     // by default, use info level
 167     let mut filter = EnvFilter::new(LevelFilter::INFO.to_string());
 168
 169     // overwrite with a more specific directive
 170     filter = filter.add_directive("hello=trace".parse().expect("directive should parse"));
 171
 172     let (subscriber, finished) = subscriber::mock()
 173         .event(event::mock().at_level(Level::INFO).with_target("hello"))
 174         .event(event::mock().at_level(Level::TRACE).with_target("hello"))
 175         .done()
 176         .run_with_handle();
 177     let subscriber = subscriber.with(filter);
 178
 179     with_default(subscriber, || {
 180         tracing::info!(target: "hello", "hello info");
 181         tracing::trace!(target: "hello", "hello trace");
 182     });
 183
 184     finished.assert_finished();
 185 }
 186
 187 #[test]
 188 fn span_name_filter_is_dynamic() {
 189     let filter: EnvFilter = "info,[cool_span]=debug"
 190         .parse()
 191         .expect("filter should parse");
 192     let (subscriber, finished) = subscriber::mock()
 193         .event(event::mock().at_level(Level::INFO))
 194         .enter(span::named("cool_span"))
 195         .event(event::mock().at_level(Level::DEBUG))
 196         .enter(span::named("uncool_span"))
 197         .event(event::mock().at_level(Level::WARN))
 198         .event(event::mock().at_level(Level::DEBUG))
 199         .exit(span::named("uncool_span"))
 200         .exit(span::named("cool_span"))
 201         .enter(span::named("uncool_span"))
 202         .event(event::mock().at_level(Level::WARN))
 203         .event(event::mock().at_level(Level::ERROR))
 204         .exit(span::named("uncool_span"))
 205         .done()
 206         .run_with_handle();
 207     let subscriber = subscriber.with(filter);
 208
 209     with_default(subscriber, || {
 210         tracing::trace!("this should be disabled");
 211         tracing::info!("this shouldn't be");
 212         let cool_span = tracing::info_span!("cool_span");
 213         let uncool_span = tracing::info_span!("uncool_span");
 214
 215         {
 216             let _enter = cool_span.enter();
 217             tracing::debug!("i'm a cool event");
 218             tracing::trace!("i'm cool, but not cool enough");
 219             let _enter2 = uncool_span.enter();
 220             tracing::warn!("warning: extremely cool!");
 221             tracing::debug!("i'm still cool");
 222         }
 223
 224         let _enter = uncool_span.enter();
 225         tracing::warn!("warning: not that cool");
 226         tracing::trace!("im not cool enough");
 227         tracing::error!("uncool error");
 228     });
 229
 230     finished.assert_finished();
 231 }
 232
 233 #[test]
 234 fn method_name_resolution() {
 235     #[allow(unused_imports)]
 236     use tracing_subscriber::layer::{Filter, Layer};
 237
 238     let filter = EnvFilter::new("hello_world=info");
 239     filter.max_level_hint();
 240 }
 241
 242 // contains the same tests as the first half of this file
 243 // but using EnvFilter as a `Filter`, not as a `Layer`
 244 mod per_layer_filter {
 245     use super::*;
 246
 247     #[test]
 248     fn level_filter_event() {
 249         let filter: EnvFilter = "info".parse().expect("filter should parse");
 250         let (layer, handle) = layer::mock()
 251             .event(event::mock().at_level(Level::INFO))
 252             .event(event::mock().at_level(Level::WARN))
 253             .event(event::mock().at_level(Level::ERROR))
 254             .done()
 255             .run_with_handle();
 256
 257         let _subscriber = tracing_subscriber::registry()
 258             .with(layer.with_filter(filter))
 259             .set_default();
 260
 261         tracing::trace!("this should be disabled");
 262         tracing::info!("this shouldn't be");
 263         tracing::debug!(target: "foo", "this should also be disabled");
 264         tracing::warn!(target: "foo", "this should be enabled");
 265         tracing::error!("this should be enabled too");
 266
 267         handle.assert_finished();
 268     }
 269
 270     #[test]
 271     fn same_name_spans() {
 272         let filter: EnvFilter = "[foo{bar}]=trace,[foo{baz}]=trace"
 273             .parse()
 274             .expect("filter should parse");
 275         let (layer, handle) = layer::mock()
 276             .new_span(
 277                 span::mock()
 278                     .named("foo")
 279                     .at_level(Level::TRACE)
 280                     .with_field(field::mock("bar")),
 281             )
 282             .new_span(
 283                 span::mock()
 284                     .named("foo")
 285                     .at_level(Level::TRACE)
 286                     .with_field(field::mock("baz")),
 287             )
 288             .done()
 289             .run_with_handle();
 290
 291         let _subscriber = tracing_subscriber::registry()
 292             .with(layer.with_filter(filter))
 293             .set_default();
 294
 295         tracing::trace_span!("foo", bar = 1);
 296         tracing::trace_span!("foo", baz = 1);
 297
 298         handle.assert_finished();
 299     }
 300
 301     #[test]
 302     fn level_filter_event_with_target() {
 303         let filter: EnvFilter = "info,stuff=debug".parse().expect("filter should parse");
 304         let (layer, handle) = layer::mock()
 305             .event(event::mock().at_level(Level::INFO))
 306             .event(event::mock().at_level(Level::DEBUG).with_target("stuff"))
 307             .event(event::mock().at_level(Level::WARN).with_target("stuff"))
 308             .event(event::mock().at_level(Level::ERROR))
 309             .event(event::mock().at_level(Level::ERROR).with_target("stuff"))
 310             .done()
 311             .run_with_handle();
 312
 313         let _subscriber = tracing_subscriber::registry()
 314             .with(layer.with_filter(filter))
 315             .set_default();
 316
 317         tracing::trace!("this should be disabled");
 318         tracing::info!("this shouldn't be");
 319         tracing::debug!(target: "stuff", "this should be enabled");
 320         tracing::debug!("but this shouldn't");
 321         tracing::trace!(target: "stuff", "and neither should this");
 322         tracing::warn!(target: "stuff", "this should be enabled");
 323         tracing::error!("this should be enabled too");
 324         tracing::error!(target: "stuff", "this should be enabled also");
 325
 326         handle.assert_finished();
 327     }
 328
 329     #[test]
 330     fn level_filter_event_with_target_and_span() {
 331         let filter: EnvFilter = "stuff[cool_span]=debug"
 332             .parse()
 333             .expect("filter should parse");
 334
 335         let cool_span = span::named("cool_span");
 336         let (layer, handle) = layer::mock()
 337             .enter(cool_span.clone())
 338             .event(
 339                 event::mock()
 340                     .at_level(Level::DEBUG)
 341                     .in_scope(vec![cool_span.clone()]),
 342             )
 343             .exit(cool_span)
 344             .done()
 345             .run_with_handle();
 346
 347         let _subscriber = tracing_subscriber::registry()
 348             .with(layer.with_filter(filter))
 349             .set_default();
 350
 351         {
 352             let _span = tracing::info_span!(target: "stuff", "cool_span").entered();
 353             tracing::debug!("this should be enabled");
 354         }
 355
 356         tracing::debug!("should also be disabled");
 357
 358         {
 359             let _span = tracing::info_span!("uncool_span").entered();
 360             tracing::debug!("this should be disabled");
 361         }
 362
 363         handle.assert_finished();
 364     }
 365
 366     #[test]
 367     fn not_order_dependent() {
 368         // this test reproduces tokio-rs/tracing#623
 369
 370         let filter: EnvFilter = "stuff=debug,info".parse().expect("filter should parse");
 371         let (layer, finished) = layer::mock()
 372             .event(event::mock().at_level(Level::INFO))
 373             .event(event::mock().at_level(Level::DEBUG).with_target("stuff"))
 374             .event(event::mock().at_level(Level::WARN).with_target("stuff"))
 375             .event(event::mock().at_level(Level::ERROR))
 376             .event(event::mock().at_level(Level::ERROR).with_target("stuff"))
 377             .done()
 378             .run_with_handle();
 379
 380         let _subscriber = tracing_subscriber::registry()
 381             .with(layer.with_filter(filter))
 382             .set_default();
 383
 384         tracing::trace!("this should be disabled");
 385         tracing::info!("this shouldn't be");
 386         tracing::debug!(target: "stuff", "this should be enabled");
 387         tracing::debug!("but this shouldn't");
 388         tracing::trace!(target: "stuff", "and neither should this");
 389         tracing::warn!(target: "stuff", "this should be enabled");
 390         tracing::error!("this should be enabled too");
 391         tracing::error!(target: "stuff", "this should be enabled also");
 392
 393         finished.assert_finished();
 394     }
 395
 396     #[test]
 397     fn add_directive_enables_event() {
 398         // this test reproduces tokio-rs/tracing#591
 399
 400         // by default, use info level
 401         let mut filter = EnvFilter::new(LevelFilter::INFO.to_string());
 402
 403         // overwrite with a more specific directive
 404         filter = filter.add_directive("hello=trace".parse().expect("directive should parse"));
 405
 406         let (layer, finished) = layer::mock()
 407             .event(event::mock().at_level(Level::INFO).with_target("hello"))
 408             .event(event::mock().at_level(Level::TRACE).with_target("hello"))
 409             .done()
 410             .run_with_handle();
 411
 412         let _subscriber = tracing_subscriber::registry()
 413             .with(layer.with_filter(filter))
 414             .set_default();
 415
 416         tracing::info!(target: "hello", "hello info");
 417         tracing::trace!(target: "hello", "hello trace");
 418
 419         finished.assert_finished();
 420     }
 421
 422     #[test]
 423     fn span_name_filter_is_dynamic() {
 424         let filter: EnvFilter = "info,[cool_span]=debug"
 425             .parse()
 426             .expect("filter should parse");
 427         let cool_span = span::named("cool_span");
 428         let uncool_span = span::named("uncool_span");
 429         let (layer, finished) = layer::mock()
 430             .event(event::mock().at_level(Level::INFO))
 431             .enter(cool_span.clone())
 432             .event(
 433                 event::mock()
 434                     .at_level(Level::DEBUG)
 435                     .in_scope(vec![cool_span.clone()]),
 436             )
 437             .enter(uncool_span.clone())
 438             .event(
 439                 event::mock()
 440                     .at_level(Level::WARN)
 441                     .in_scope(vec![uncool_span.clone()]),
 442             )
 443             .event(
 444                 event::mock()
 445                     .at_level(Level::DEBUG)
 446                     .in_scope(vec![uncool_span.clone()]),
 447             )
 448             .exit(uncool_span.clone())
 449             .exit(cool_span)
 450             .enter(uncool_span.clone())
 451             .event(
 452                 event::mock()
 453                     .at_level(Level::WARN)
 454                     .in_scope(vec![uncool_span.clone()]),
 455             )
 456             .event(
 457                 event::mock()
 458                     .at_level(Level::ERROR)
 459                     .in_scope(vec![uncool_span.clone()]),
 460             )
 461             .exit(uncool_span)
 462             .done()
 463             .run_with_handle();
 464
 465         let _subscriber = tracing_subscriber::registry()
 466             .with(layer.with_filter(filter))
 467             .set_default();
 468
 469         tracing::trace!("this should be disabled");
 470         tracing::info!("this shouldn't be");
 471         let cool_span = tracing::info_span!("cool_span");
 472         let uncool_span = tracing::info_span!("uncool_span");
 473
 474         {
 475             let _enter = cool_span.enter();
 476             tracing::debug!("i'm a cool event");
 477             tracing::trace!("i'm cool, but not cool enough");
 478             let _enter2 = uncool_span.enter();
 479             tracing::warn!("warning: extremely cool!");
 480             tracing::debug!("i'm still cool");
 481         }
 482
 483         {
 484             let _enter = uncool_span.enter();
 485             tracing::warn!("warning: not that cool");
 486             tracing::trace!("im not cool enough");
 487             tracing::error!("uncool error");
 488         }
 489
 490         finished.assert_finished();
 491     }
 492
 493     #[test]
 494     fn multiple_dynamic_filters() {
 495         // Test that multiple dynamic (span) filters only apply to the layers
 496         // they're attached to.
 497         let (layer1, handle1) = {
 498             let span = span::named("span1");
 499             let filter: EnvFilter = "[span1]=debug".parse().expect("filter 1 should parse");
 500             let (layer, handle) = layer::named("layer1")
 501                 .enter(span.clone())
 502                 .event(
 503                     event::mock()
 504                         .at_level(Level::DEBUG)
 505                         .in_scope(vec![span.clone()]),
 506                 )
 507                 .exit(span)
 508                 .done()
 509                 .run_with_handle();
 510             (layer.with_filter(filter), handle)
 511         };
 512
 513         let (layer2, handle2) = {
 514             let span = span::named("span2");
 515             let filter: EnvFilter = "[span2]=info".parse().expect("filter 2 should parse");
 516             let (layer, handle) = layer::named("layer2")
 517                 .enter(span.clone())
 518                 .event(
 519                     event::mock()
 520                         .at_level(Level::INFO)
 521                         .in_scope(vec![span.clone()]),
 522                 )
 523                 .exit(span)
 524                 .done()
 525                 .run_with_handle();
 526             (layer.with_filter(filter), handle)
 527         };
 528
 529         let _subscriber = tracing_subscriber::registry()
 530             .with(layer1)
 531             .with(layer2)
 532             .set_default();
 533
 534         tracing::info_span!("span1").in_scope(|| {
 535             tracing::debug!("hello from span 1");
 536             tracing::trace!("not enabled");
 537         });
 538
 539         tracing::info_span!("span2").in_scope(|| {
 540             tracing::info!("hello from span 2");
 541             tracing::debug!("not enabled");
 542         });
 543
 544         handle1.assert_finished();
 545         handle2.assert_finished();
 546     }
 547 }