test(s2n-events): Generate test events system (#2795)

Author: goatgoose

.github/workflows/ci.yml

@@ -669,23 +669,26 @@ jobs:
         with:
           submodules: true
 
-      # nightly features are used for formatting
-      - name: Install rust nightly toolchain
-        id: nightly-toolchain
-        run: |
-          rustup toolchain install nightly --component rustfmt
-
-      - name: Install rust stable toolchain
-        id: stable-toolchain
+      - name: Install rust toolchain
+        id: toolchain
         run: |
-          rustup toolchain install stable
-          rustup override set stable
+          rustup toolchain install ${{ env.RUST_NIGHTLY_TOOLCHAIN }} --profile minimal --component rustfmt
+          rustup override set ${{ env.RUST_NIGHTLY_TOOLCHAIN }}
 
       - uses: camshaft/rust-cache@v1
 
       - name: format
         working-directory: ./tools/s2n-events
-        run: cargo +nightly fmt -- --check
+        run: cargo fmt -- --check
+
+      - name: generate test events
+        run: |
+          cargo run --manifest-path ./tools/s2n-events/Cargo.toml
+
+      - name: ensure test events are up to date
+        run: |
+          # If this fails you need to run `cargo run --manifest-path ./tools/s2n-events/Cargo.toml`
+          git diff --exit-code
 
       - name: test
         working-directory: ./tools/s2n-events

tools/s2n-events/Cargo.toml

@@ -9,6 +9,9 @@ license = "Apache-2.0"
 # This is a commit-time crate and should not be published
 publish = false
 
+[features]
+testing = []
+
 [dependencies]
 glob = "0.3"
 heck = "0.5"
@@ -18,3 +21,7 @@ syn = { version = "2", features = ["full", "extra-traits"] }
 
 [workspace]
 members = ["."]
+
+[dev-dependencies]
+s2n-quic-core = { path = "../../quic/s2n-quic-core", features = ["testing"] }
+tracing = { version = "0.1" }

tools/s2n-events/src/bin/generate_test_events.rs

@@ -0,0 +1,97 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use s2n_events::{parser, validation, Output, Result};
+
+struct EventInfo<'a> {
+    input_path: &'a str,
+    output_path: &'a str,
+    crate_name: &'a str,
+    s2n_quic_core_path: TokenStream,
+    builder: TokenStream,
+    tracing_subscriber_def: TokenStream,
+}
+
+impl EventInfo<'_> {
+    fn test_c_ffi_events() -> Self {
+        let tracing_subscriber_def = quote!(
+        /// Emits events with [`tracing`](https://docs.rs/tracing)
+        #[derive(Clone, Debug)]
+        pub struct Subscriber {
+            root: tracing::Span,
+        }
+
+        impl Default for Subscriber {
+            fn default() -> Self {
+                let root = tracing::span!(target: "c_ffi_events_test", tracing::Level::DEBUG, "c_ffi_events_test");
+
+                Self {
+                    root,
+                }
+            }
+        }
+
+        impl Subscriber {
+            fn parent<M: crate::event::Meta>(&self, _meta: &M) -> Option<tracing::Id> {
+                self.root.id()
+            }
+        }
+        );
+
+        EventInfo {
+            crate_name: "c_ffi_events",
+            input_path: concat!(
+                env!("CARGO_MANIFEST_DIR"),
+                "/tests/c_ffi_events/events/**/*.rs"
+            ),
+            output_path: concat!(env!("CARGO_MANIFEST_DIR"), "/tests/c_ffi_events/event"),
+            s2n_quic_core_path: quote!(s2n_quic_core),
+            builder: quote! {
+                pub use s2n_quic_core::event::builder::SocketAddress;
+            },
+            tracing_subscriber_def,
+        }
+    }
+}
+
+fn main() -> Result<()> {
+    let event_paths = [EventInfo::test_c_ffi_events()];
+
+    for event_info in event_paths {
+        let mut files = vec![];
+
+        let input_path = event_info.input_path;
+
+        for path in glob::glob(input_path)? {
+            let path = path?;
+            eprintln!("loading {}", path.canonicalize().unwrap().display());
+            let file = std::fs::read_to_string(&path)?;
+            files.push(parser::parse(&file, path).unwrap());
+        }
+
+        // make sure events are in a deterministic order
+        files.sort_by(|a, b| a.path.as_os_str().cmp(b.path.as_os_str()));
+
+        // validate the events
+        validation::validate(&files);
+
+        let root = std::path::Path::new(event_info.output_path);
+        let _ = std::fs::create_dir_all(root);
+        let root = root.canonicalize()?;
+
+        let mut output = Output {
+            s2n_quic_core_path: event_info.s2n_quic_core_path,
+            builders: event_info.builder,
+            tracing_subscriber_def: event_info.tracing_subscriber_def,
+            crate_name: event_info.crate_name,
+            root,
+            ..Default::default()
+        };
+
+        output.generate(&files);
+    }
+
+    Ok(())
+}

tools/s2n-events/tests/c_ffi_events/event.rs

@@ -0,0 +1,44 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+pub use s2n_quic_core::event::{Event, IntoEvent, Timestamp};
+
+#[cfg(any(test, feature = "testing"))]
+use s2n_quic_core::event::snapshot;
+
+pub trait Meta: core::fmt::Debug {
+    fn subject(&self) -> api::Subject;
+}
+
+impl Meta for api::ConnectionMeta {
+    fn subject(&self) -> api::Subject {
+        builder::Subject::Connection { id: self.id }.into_event()
+    }
+}
+
+impl Meta for api::EndpointMeta {
+    fn subject(&self) -> api::Subject {
+        builder::Subject::Endpoint {}.into_event()
+    }
+}
+
+mod generated;
+pub use generated::*;
+pub use s2n_quic_core::time::Duration;
+
+pub mod metrics {
+    pub use crate::event::generated::metrics::*;
+    pub use s2n_quic_core::event::metrics::Recorder;
+
+    pub mod aggregate {
+        pub use crate::event::generated::metrics::aggregate::*;
+        pub use s2n_quic_core::event::metrics::aggregate::{
+            info, AsVariant, BoolRecorder, Info, Metric, NominalRecorder, Recorder, Registry, Units,
+        };
+
+        pub mod probe {
+            pub use crate::event::generated::metrics::probe::*;
+            pub use s2n_quic_core::event::metrics::aggregate::probe::dynamic;
+        }
+    }
+}