feat: Remove yaml configuration

Author: timfish

Cargo.lock

@@ -9,17 +9,15 @@ license = "Apache-2.0"
 # crate-type = ["cdylib"]
 # This was originally set as above, but commented to run tests in tests folder.
 
-
 [profile.release]
 lto = true
 
 [dependencies]
-nodejs-semver = "4.1.0"
-swc = "16.1.0"
-swc_core = { version = "16.2.3", features = ["ecma_plugin_transform","ecma_quote"] }
-swc_ecma_parser = "10.0.0"
-swc_ecma_visit = { version = "8.0.0", features = ["path"] }
-yaml-rust2 = "0.10.0"
+nodejs-semver = "4"
+swc = "21"
+swc_core = { version = "22", features = ["ecma_plugin_transform","ecma_quote"] }
+swc_ecma_parser = "11"
+swc_ecma_visit = { version = "8", features = ["path"] }
 
 [dev-dependencies]
-assert_cmd = "2.0.16"
+assert_cmd = "2"

Cargo.toml

@@ -2,30 +2,9 @@
  * Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License.
  * This product includes software developed at Datadog (<https://www.datadoghq.com>/). Copyright 2025 Datadog, Inc.
  **/
-use std::path::PathBuf;
-
-use nodejs_semver::{Range, Version};
-
-use crate::error::OrchestrionError;
 use crate::function_query::FunctionQuery;
-
-use yaml_rust2::{Yaml, YamlLoader};
-
-macro_rules! get_str {
-    ($property:expr, $name:expr) => {
-        $property[$name]
-            .as_str()
-            .ok_or(format!("Invalid config: '{}' must be a string", $name))?
-    };
-}
-
-macro_rules! get_arr {
-    ($property:expr, $name:expr) => {
-        $property[$name]
-            .as_vec()
-            .ok_or(format!("Invalid config: '{}' must be a array", $name))?
-    };
-}
+use nodejs_semver::{Range, Version};
+use std::path::PathBuf;
 
 #[derive(Clone, Debug)]
 pub enum InstrumentationOperator {
@@ -36,6 +15,7 @@ pub enum InstrumentationOperator {
 }
 
 impl InstrumentationOperator {
+    #[must_use]
     pub fn as_str(&self) -> &'static str {
         match self {
             InstrumentationOperator::Callback => "traceCallback",
@@ -44,19 +24,9 @@ impl InstrumentationOperator {
             InstrumentationOperator::Async => "traceAsync",
         }
     }
-
-    pub fn from_str(s: &str) -> Option<InstrumentationOperator> {
-        match s {
-            "traceCallback" => Some(InstrumentationOperator::Callback),
-            "tracePromise" => Some(InstrumentationOperator::Promise),
-            "traceSync" => Some(InstrumentationOperator::Sync),
-            "traceAsync" => Some(InstrumentationOperator::Async),
-            _ => None,
-        }
-    }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct InstrumentationConfig {
     pub module_name: String,
     pub version_range: Range,
@@ -66,85 +36,43 @@ pub struct InstrumentationConfig {
     pub channel_name: String,
 }
 
+#[derive(Debug, Clone)]
 pub struct Config {
     pub instrumentations: Vec<InstrumentationConfig>,
     pub dc_module: String,
 }
 
 impl Config {
-    pub fn from_yaml_data(yaml_str: &str) -> Result<Config, OrchestrionError> {
-        let docs = YamlLoader::load_from_str(yaml_str)?;
-        let doc = &docs[0];
-
-        let version = doc["version"]
-            .as_i64()
-            .ok_or("Invalid config: 'version' must be a number")?;
-        if version != 1 {
-            return Err("Invalid config version".into());
+    #[must_use]
+    pub fn new(instrumentations: Vec<InstrumentationConfig>, dc_module: String) -> Self {
+        Self {
+            instrumentations,
+            dc_module,
         }
-
-        let dc_module = doc["dc_module"].as_str().unwrap_or("diagnostics_channel");
-
-        let configs = InstrumentationConfig::from_yaml(doc)?;
-
-        Ok(Config {
-            instrumentations: configs,
-            dc_module: dc_module.to_string(),
-        })
     }
-}
-
-impl InstrumentationConfig {
-    pub fn from_yaml(doc: &Yaml) -> Result<Vec<InstrumentationConfig>, OrchestrionError> {
-        let instrumentations = get_arr!(doc, "instrumentations");
-        let mut configs = Vec::new();
 
-        for instr in instrumentations {
-            instr
-                .as_hash()
-                .ok_or("Invalid config: 'instrumentations' must be a array of objects")?;
-            configs.push(instr.try_into()?);
+    #[must_use]
+    pub fn new_single_with_default_dc_module(instrumentation: InstrumentationConfig) -> Self {
+        Self {
+            instrumentations: vec![instrumentation],
+            dc_module: "diagnostics_channel".to_string(),
         }
-
-        Ok(configs)
     }
+}
 
+impl InstrumentationConfig {
+    #[must_use]
     pub fn matches(&self, module_name: &str, version: &str, file_path: &PathBuf) -> bool {
         let version: Version = match version.parse() {
             Ok(v) => v,
-            Err(_) => return false,
+            Err(e) => {
+                println!("Failed to parse version {version}: {e}");
+                return false;
+            }
         };
+
         self.module_name == module_name
             && version.satisfies(&self.version_range)
             && self.file_path == *file_path
     }
 }
-
-impl TryFrom<&Yaml> for InstrumentationConfig {
-    type Error = OrchestrionError;
-
-    fn try_from(instr: &Yaml) -> Result<Self, Self::Error> {
-        let module_name = get_str!(instr, "module_name");
-        let version_range = get_str!(instr, "version_range");
-        let version_range: Range = version_range
-            .parse()
-            .map_err(|_| format!("Invalid version range: {version_range}"))?;
-        let file_path = PathBuf::from(get_str!(instr, "file_path"));
-        if instr["function_query"].as_hash().is_none() {
-            return Err("Invalid config: 'function_query' must be a object".into());
-        }
-        let function_query = (&instr["function_query"]).try_into()?;
-        let operator = InstrumentationOperator::from_str(get_str!(instr, "operator"))
-            .unwrap_or(InstrumentationOperator::Sync);
-        let channel_name = get_str!(instr, "channel_name");
-
-        Ok(InstrumentationConfig {
-            module_name: module_name.to_string(),
-            version_range,
-            file_path,
-            function_query,
-            operator,
-            channel_name: channel_name.to_string(),
-        })
-    }
-}

src/config.rs

@@ -6,9 +6,7 @@ use std::fmt::{self, Display, Formatter};
 
 #[derive(Debug)]
 pub enum OrchestrionError {
-    InvalidVersionRange(String),
     IoError(std::io::Error),
-    YamlParseError(yaml_rust2::ScanError),
     StrError(String),
 }
 
@@ -18,12 +16,6 @@ impl From<std::io::Error> for OrchestrionError {
     }
 }
 
-impl From<yaml_rust2::ScanError> for OrchestrionError {
-    fn from(e: yaml_rust2::ScanError) -> Self {
-        OrchestrionError::YamlParseError(e)
-    }
-}
-
 impl From<String> for OrchestrionError {
     fn from(s: String) -> Self {
         OrchestrionError::StrError(s)
@@ -39,9 +31,7 @@ impl From<&str> for OrchestrionError {
 impl Display for OrchestrionError {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         match self {
-            OrchestrionError::InvalidVersionRange(s) => write!(f, "Invalid version range: {s}"),
             OrchestrionError::IoError(e) => write!(f, "IO error: {e}"),
-            OrchestrionError::YamlParseError(e) => write!(f, "YAML parse error: {e}"),
             OrchestrionError::StrError(s) => write!(f, "String error: {s}"),
         }
     }

src/error.rs

@@ -2,37 +2,16 @@
  * Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License.
  * This product includes software developed at Datadog (<https://www.datadoghq.com>/). Copyright 2025 Datadog, Inc.
  **/
-use crate::error::OrchestrionError;
 use swc_core::ecma::ast::{FnDecl, FnExpr, Function};
-use yaml_rust2::Yaml;
 
-macro_rules! get_str {
-    ($property:expr, $name:expr) => {
-        $property[$name]
-            .as_str()
-            .ok_or(format!("Invalid config: '{}' must be a string", $name))?
-    };
-}
-
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum FunctionType {
     FunctionDeclaration,
     FunctionExpression,
     Method,
 }
 
-impl FunctionType {
-    pub fn from_str(s: &str) -> Option<FunctionType> {
-        match s {
-            "decl" => Some(FunctionType::FunctionDeclaration),
-            "expr" => Some(FunctionType::FunctionExpression),
-            "method" => Some(FunctionType::Method),
-            _ => None,
-        }
-    }
-}
-
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum FunctionKind {
     Sync,
     Async,
@@ -41,14 +20,17 @@ pub enum FunctionKind {
 }
 
 impl FunctionKind {
+    #[must_use]
     pub fn is_async(&self) -> bool {
         matches!(self, FunctionKind::Async | FunctionKind::AsyncGenerator)
     }
 
+    #[must_use]
     pub fn is_generator(&self) -> bool {
         matches!(self, FunctionKind::Generator | FunctionKind::AsyncGenerator)
     }
 
+    #[must_use]
     pub fn matches(&self, func: &Function) -> bool {
         match self {
             FunctionKind::Sync => !func.is_async && !func.is_generator,
@@ -57,19 +39,9 @@ impl FunctionKind {
             FunctionKind::AsyncGenerator => func.is_async && func.is_generator,
         }
     }
-
-    pub fn from_str(s: &str) -> Option<FunctionKind> {
-        match s {
-            "sync" => Some(FunctionKind::Sync),
-            "async" => Some(FunctionKind::Async),
-            "generator" => Some(FunctionKind::Generator),
-            "async generator" => Some(FunctionKind::AsyncGenerator),
-            _ => None,
-        }
-    }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct FunctionQuery {
     pub name: String,
     pub class: Option<String>,
@@ -113,29 +85,3 @@ impl FunctionQuery {
         self.maybe_increment_count(matches_except_count, count)
     }
 }
-
-impl TryFrom<&Yaml> for FunctionQuery {
-    type Error = OrchestrionError;
-
-    fn try_from(query: &Yaml) -> Result<Self, Self::Error> {
-        let typ = get_str!(query, "type");
-        let kind = get_str!(query, "kind");
-        let name = get_str!(query, "name");
-        let class = query["class"]
-            .as_str()
-            .map(std::string::ToString::to_string);
-        let index: usize = query["index"].as_i64().unwrap_or(0).try_into().unwrap_or(0);
-
-        Ok(FunctionQuery {
-            name: name.to_string(),
-            class,
-            typ: FunctionType::from_str(typ).ok_or(format!(
-                "Invalid config: 'type' must be one of 'decl', 'expr', or 'method', got '{typ}'"
-            ))?,
-            kind: FunctionKind::from_str(kind).ok_or(format!(
-                "Invalid config: 'kind' must be one of 'sync', 'async', 'generator', or 'async generator', got '{kind}'"
-            ))?,
-            index,
-        })
-    }
-}

src/function_query.rs

@@ -27,14 +27,16 @@ macro_rules! ident {
 ///
 /// [`Instrumentation`]: Instrumentation
 /// [`VisitMut`]: https://rustdoc.swc.rs/swc_core/ecma/visit/trait.VisitMut.html
+#[derive(Debug)]
 pub struct Instrumentation {
     config: InstrumentationConfig,
     count: usize,
     is_correct_class: bool,
 }
 
 impl Instrumentation {
-    pub(crate) fn new(config: InstrumentationConfig) -> Self {
+    #[must_use]
+    pub fn new(config: InstrumentationConfig) -> Self {
         Self {
             config,
             count: 0,
@@ -230,7 +232,7 @@ impl Instrumentation {
             .function_query
             .class
             .as_ref()
-            .map_or(true, |class| node.ident.sym.as_ref() == class);
+            .is_none_or(|class| node.ident.sym.as_ref() == class);
         true
     }