chore: cargo fmt

Author: nickysn

runtime_tracing/src/abstract_trace_writer.rs

@@ -1,6 +1,16 @@
-use std::{collections::HashMap, env, error::Error, fs, path::{Path, PathBuf}};
-
-use crate::{tracer::TOP_LEVEL_FUNCTION_ID, AssignCellRecord, AssignCompoundItemRecord, AssignmentRecord, CallRecord, CellValueRecord, CompoundValueRecord, FullValueRecord, FunctionId, FunctionRecord, Line, PathId, RValue, RecordEvent, ReturnRecord, StepRecord, TraceLowLevelEvent, TraceMetadata, TypeId, TypeKind, TypeRecord, TypeSpecificInfo, VariableCellRecord, VariableId, NONE_TYPE_ID};
+use std::{
+    collections::HashMap,
+    env,
+    error::Error,
+    fs,
+    path::{Path, PathBuf},
+};
+
+use crate::{
+    AssignCellRecord, AssignCompoundItemRecord, AssignmentRecord, CallRecord, CellValueRecord, CompoundValueRecord, FullValueRecord, FunctionId,
+    FunctionRecord, Line, NONE_TYPE_ID, PathId, RValue, RecordEvent, ReturnRecord, StepRecord, TraceLowLevelEvent, TraceMetadata, TypeId, TypeKind,
+    TypeRecord, TypeSpecificInfo, VariableCellRecord, VariableId, tracer::TOP_LEVEL_FUNCTION_ID,
+};
 
 pub struct AbstractTraceWriterData {
     // trace metadata:

runtime_tracing/src/cbor_zstd_reader.rs

@@ -3,14 +3,14 @@ use std::io::{self, BufRead, BufReader, Read, Seek, Write};
 use fscommon::StreamSlice;
 use zeekstd::Decoder;
 
-use crate::{cbor_zstd_writer::HEADERV1, TraceLowLevelEvent};
+use crate::{TraceLowLevelEvent, cbor_zstd_writer::HEADERV1};
 
 fn is_at_eof<R: BufRead>(reader: &mut R) -> io::Result<bool> {
     let buffer = reader.fill_buf()?;
     Ok(buffer.is_empty())
 }
 
-pub fn read_trace(input: &mut (impl Read + Write + Seek)) -> Result<Vec<TraceLowLevelEvent>,  Box<dyn std::error::Error>> {
+pub fn read_trace(input: &mut (impl Read + Write + Seek)) -> Result<Vec<TraceLowLevelEvent>, Box<dyn std::error::Error>> {
     let end_pos = input.seek(io::SeekFrom::End(0))?;
     input.seek(io::SeekFrom::Start(0))?;
 

runtime_tracing/src/cbor_zstd_writer.rs

@@ -1,14 +1,19 @@
 use std::{fs::File, io::Write, path::PathBuf};
 use zeekstd::Encoder;
 
-use crate::{abstract_trace_writer::{AbstractTraceWriter, AbstractTraceWriterData}, trace_writer::TraceWriter, TraceLowLevelEvent};
+use crate::{
+    TraceLowLevelEvent,
+    abstract_trace_writer::{AbstractTraceWriter, AbstractTraceWriterData},
+    trace_writer::TraceWriter,
+};
 
 /// The next 3 bytes are reserved/version info.
 /// The header is 8 bytes in size, ensuring 64-bit alignment for the rest of the file.
 pub const HEADERV1: &[u8] = &[
-    0xC0, 0xDE, 0x72, 0xAC, 0xE2,  // The first 5 bytes identify the file as a CodeTracer file (hex l33tsp33k - C0DE72ACE2 for "CodeTracer").
-    0x01,                          // Indicates version 1 of the file format
-    0x00, 0x00];                   // Reserved, must be zero in this version.
+    0xC0, 0xDE, 0x72, 0xAC, 0xE2, // The first 5 bytes identify the file as a CodeTracer file (hex l33tsp33k - C0DE72ACE2 for "CodeTracer").
+    0x01, // Indicates version 1 of the file format
+    0x00, 0x00,
+]; // Reserved, must be zero in this version.
 
 pub struct CborZstdTraceWriter<'a> {
     base: AbstractTraceWriterData,
@@ -33,7 +38,7 @@ impl<'a> AbstractTraceWriter for CborZstdTraceWriter<'a> {
     fn get_data(&self) -> &AbstractTraceWriterData {
         &self.base
     }
-    
+
     fn get_mut_data(&mut self) -> &mut AbstractTraceWriterData {
         &mut self.base
     }

runtime_tracing/src/lib.rs

@@ -8,23 +8,21 @@
 //! This crate provides the [`Tracer`] type for emitting trace events and a
 //! collection of serializable structures describing the trace format.
 //! The format is documented in `docs/` and the README.
+mod abstract_trace_writer;
 mod base64;
 mod capnptrace;
-mod tracer;
-mod types;
 mod cbor_zstd_reader;
 mod cbor_zstd_writer;
-mod abstract_trace_writer;
+mod non_streaming_trace_writer;
 mod trace_readers;
 mod trace_writer;
-mod non_streaming_trace_writer;
+mod tracer;
+mod types;
 
-pub use crate::tracer::{
-    create_trace_reader, create_trace_writer, TraceEventsFileFormat, NONE_TYPE_ID, NONE_VALUE,
-};
+pub use crate::non_streaming_trace_writer::NonStreamingTraceWriter;
 pub use crate::trace_readers::TraceReader;
 pub use crate::trace_writer::TraceWriter;
-pub use crate::non_streaming_trace_writer::NonStreamingTraceWriter;
+pub use crate::tracer::{NONE_TYPE_ID, NONE_VALUE, TraceEventsFileFormat, create_trace_reader, create_trace_writer};
 pub use crate::types::*;
 
 pub mod trace_capnp {

runtime_tracing/src/non_streaming_trace_writer.rs

@@ -1,6 +1,13 @@
-use std::{error::Error, fs, path::{Path, PathBuf}};
+use std::{
+    error::Error,
+    fs,
+    path::{Path, PathBuf},
+};
 
-use crate::{abstract_trace_writer::{AbstractTraceWriter, AbstractTraceWriterData}, TraceEventsFileFormat, TraceLowLevelEvent, TraceWriter};
+use crate::{
+    TraceEventsFileFormat, TraceLowLevelEvent, TraceWriter,
+    abstract_trace_writer::{AbstractTraceWriter, AbstractTraceWriterData},
+};
 
 /// State machine used to record [`TraceLowLevelEvent`]s.
 ///

runtime_tracing/src/trace_readers.rs

@@ -1,6 +1,11 @@
-use std::{error::Error, fs::{self, File}, io::{BufReader, Read, Seek, SeekFrom}, path::Path};
+use std::{
+    error::Error,
+    fs::{self, File},
+    io::{BufReader, Read, Seek, SeekFrom},
+    path::Path,
+};
 
-use crate::{capnptrace::HEADER, cbor_zstd_writer::HEADERV1, TraceEventsFileFormat, TraceLowLevelEvent};
+use crate::{TraceEventsFileFormat, TraceLowLevelEvent, capnptrace::HEADER, cbor_zstd_writer::HEADERV1};
 
 pub trait TraceReader {
     fn load_trace_events(&mut self, path: &Path) -> Result<Vec<TraceLowLevelEvent>, Box<dyn Error>>;
@@ -41,9 +46,7 @@ impl TraceReader for BinaryTraceReader {
                 let mut buf_reader = BufReader::new(file);
                 Ok(crate::capnptrace::read_trace(&mut buf_reader)?)
             }
-            Some(TraceEventsFileFormat::Binary) => {
-                Ok(crate::cbor_zstd_reader::read_trace(&mut file)?)
-            }
+            Some(TraceEventsFileFormat::Binary) => Ok(crate::cbor_zstd_reader::read_trace(&mut file)?),
             Some(TraceEventsFileFormat::Json) => {
                 unreachable!()
             }

runtime_tracing/src/trace_writer.rs

@@ -1,6 +1,9 @@
 use std::{error::Error, path::Path};
 
-use crate::{abstract_trace_writer::AbstractTraceWriter, EventLogKind, FullValueRecord, FunctionId, Line, PassBy, PathId, Place, RValue, TraceLowLevelEvent, TypeId, TypeKind, TypeRecord, ValueRecord, VariableId};
+use crate::{
+    EventLogKind, FullValueRecord, FunctionId, Line, PassBy, PathId, Place, RValue, TraceLowLevelEvent, TypeId, TypeKind, TypeRecord, ValueRecord,
+    VariableId, abstract_trace_writer::AbstractTraceWriter,
+};
 
 pub trait TraceWriter: AbstractTraceWriter {
     fn begin_writing_trace_metadata(&mut self, path: &Path) -> Result<(), Box<dyn Error>> {

runtime_tracing/src/tracer.rs

@@ -1,18 +1,15 @@
 //! Helper for generating trace events from a running program or interpreter.
 
+use crate::TraceWriter;
 use crate::non_streaming_trace_writer::NonStreamingTraceWriter;
 use crate::trace_readers::{BinaryTraceReader, JsonTraceReader, TraceReader};
-use crate::types::{
-    FunctionId, TypeId,
-    ValueRecord,
-};
-use crate::TraceWriter;
+use crate::types::{FunctionId, TypeId, ValueRecord};
 
 #[derive(Debug, Clone, Copy)]
 pub enum TraceEventsFileFormat {
     Json,
     BinaryV0,
-    Binary
+    Binary,
 }
 
 // we ensure in start they are registered with those id-s
@@ -26,25 +23,20 @@ pub const NONE_VALUE: ValueRecord = ValueRecord::None { type_id: NONE_TYPE_ID };
 
 pub const TOP_LEVEL_FUNCTION_ID: FunctionId = FunctionId(0);
 
-
 pub fn create_trace_reader(format: TraceEventsFileFormat) -> Box<dyn TraceReader> {
     match format {
         TraceEventsFileFormat::Json => Box::new(JsonTraceReader {}),
-        TraceEventsFileFormat::BinaryV0 |
-        TraceEventsFileFormat::Binary => Box::new(BinaryTraceReader {}),
+        TraceEventsFileFormat::BinaryV0 | TraceEventsFileFormat::Binary => Box::new(BinaryTraceReader {}),
     }
 }
 
 pub fn create_trace_writer(program: &str, args: &[String], format: TraceEventsFileFormat) -> Box<dyn TraceWriter> {
     match format {
-        TraceEventsFileFormat::Json |
-        TraceEventsFileFormat::BinaryV0 => {
+        TraceEventsFileFormat::Json | TraceEventsFileFormat::BinaryV0 => {
             let mut result = Box::new(NonStreamingTraceWriter::new(program, args));
             result.set_format(format);
             result
         }
-        TraceEventsFileFormat::Binary => {
-            Box::new(crate::cbor_zstd_writer::CborZstdTraceWriter::new(program, args))
-        }
+        TraceEventsFileFormat::Binary => Box::new(crate::cbor_zstd_writer::CborZstdTraceWriter::new(program, args)),
     }
 }

runtime_tracing/tests/binary_format.rs

@@ -1,4 +1,4 @@
-use runtime_tracing::{create_trace_reader, create_trace_writer, TraceEventsFileFormat, TraceWriter};
+use runtime_tracing::{TraceEventsFileFormat, TraceWriter, create_trace_reader, create_trace_writer};
 use std::fs;
 use std::path::Path;