effectful 0.2.1

Effect<A, E, R> (sync + async), context/layers, pipe — interpreter-style, no bundled executor
Documentation 
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
103
104
105
106
107
108

//! Ex 106 — `#[effectful::span]` instruments functions returning `Effect` lazily.
use effectful::{
  Effect, Never, SpanAttributeValue, SpanLevel, TracingConfig, install_tracing_layer, run_blocking,
  snapshot_tracing, span, succeed,
};
use std::fmt;
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};

struct Secret(String);

struct CountedDebug {
  hits: Arc<AtomicUsize>,
}

impl fmt::Debug for CountedDebug {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    self.hits.fetch_add(1, Ordering::SeqCst);
    f.write_str("CountedDebug")
  }
}

#[span(
  name = "user.load",
  level = debug,
  skip(secret),
  fields(cache_hit = true, id_display = %id)
)]
fn load_user(id: u32, secret: Secret) -> Effect<u32, Never, ()> {
  let _ = secret.0.len();
  succeed::<u32, Never, ()>(id + 1)
}

#[span(name = "user.async_load", skip_all)]
async fn async_load_user(id: u32) -> Effect<u32, Never, ()> {
  succeed::<u32, Never, ()>(id + 2)
}

#[span(name = "disabled.capture")]
fn disabled_capture(value: CountedDebug) -> Effect<(), Never, ()> {
  Effect::new(move |_env: &mut ()| {
    let _ = value.hits.load(Ordering::SeqCst);
    Ok(())
  })
}

#[span(name = "sampled.out", sample = 0.0)]
fn sampled_out_capture(value: CountedDebug) -> Effect<(), Never, ()> {
  Effect::new(move |_env: &mut ()| {
    let _ = value.hits.load(Ordering::SeqCst);
    Ok(())
  })
}

fn main() {
  let _ = run_blocking(install_tracing_layer(TracingConfig::enabled()), ());
  let eff = load_user(41, Secret("redacted".to_string()));
  assert!(snapshot_tracing().spans.is_empty());

  assert_eq!(run_blocking(eff, ()), Ok(42));
  let snap = snapshot_tracing();
  let span = snap
    .spans
    .iter()
    .find(|span| span.name == "user.load")
    .expect("span recorded");
  assert_eq!(span.level, SpanLevel::Debug);
  assert_eq!(
    span.attributes.get("id"),
    Some(&SpanAttributeValue::String("41".to_string()))
  );
  assert_eq!(span.attributes.get("secret"), None);
  assert_eq!(
    span.attributes.get("cache_hit"),
    Some(&SpanAttributeValue::Bool(true))
  );
  assert_eq!(
    span.attributes.get("id_display"),
    Some(&SpanAttributeValue::String("41".to_string()))
  );

  let eff = pollster::block_on(async_load_user(40));
  assert_eq!(run_blocking(eff, ()), Ok(42));
  assert!(
    snapshot_tracing()
      .spans
      .iter()
      .any(|span| span.name == "user.async_load")
  );

  let hits = Arc::new(AtomicUsize::new(0));
  let _ = run_blocking(install_tracing_layer(TracingConfig::default()), ());
  let eff = disabled_capture(CountedDebug {
    hits: Arc::clone(&hits),
  });
  assert_eq!(run_blocking(eff, ()), Ok(()));
  assert_eq!(hits.load(Ordering::SeqCst), 0);

  let hits = Arc::new(AtomicUsize::new(0));
  let _ = run_blocking(install_tracing_layer(TracingConfig::enabled()), ());
  let eff = sampled_out_capture(CountedDebug {
    hits: Arc::clone(&hits),
  });
  assert_eq!(run_blocking(eff, ()), Ok(()));
  assert_eq!(hits.load(Ordering::SeqCst), 0);
  assert!(snapshot_tracing().spans.is_empty());
  println!("106_span_macro ok");
}