remove chain names given it is not needed in the genral case

Author: tharinduamila-insta

docs/src/transforms.md

@@ -34,14 +34,12 @@ chain:
       name: "my-null-sink"
 ```
 
-Sub-chains inside transforms (like Tee or ValkeyCache) use a named format with `name` and `transforms` keys:
+Sub-chains inside transforms are configured as a bare list. The chain name is derived from the transform's `name` (ParallelMap appends an index), and Tee's `SubchainOnMismatch.name` can override the mismatch chain name.
 
 ```yaml
 chain:
-  name: "my-sub-chain"
-  transforms:
-    - NullSink:
-        name: "sub-sink"
+  - NullSink:
+      name: "sub-sink"
 ```
 
 ## Transforms
@@ -606,7 +604,7 @@ Tee also exposes an optional HTTP API to switch which chain to use as the "resul
     # behavior:
     #   SubchainOnMismatch:
     #     name: "mismatch-chain"
-    #     transforms:
+    #     chain:
     #       - QueryTypeFilter:
     #           name: "mismatch-filter"
     #           DenyList: [Read]
@@ -622,15 +620,13 @@ Tee also exposes an optional HTTP API to switch which chain to use as the "resul
     # The number of message batches that the tee can hold onto in its buffer of messages to send.
     # If they arent sent quickly enough and the buffer is full then tee will drop new incoming messages.
     buffer_size: 10000
-    # The sub chain to send duplicate messages through (named sub-chain format)
+    # The sub chain to send duplicate messages through
     chain:
-      name: "tee-chain"
-      transforms:
-        - QueryTypeFilter:
-            name: "tee-filter"
-            DenyList: [Read]
-        - NullSink:
-            name: "tee-sink"
+      - QueryTypeFilter:
+          name: "tee-filter"
+          DenyList: [Read]
+      - NullSink:
+          name: "tee-sink"
 ```
 
 This transform emits a metrics [counter](user-guide/observability.md#counter) named `tee_dropped_messages` and the label `chain` as `Tee`.

shotover/src/config/chain.rs

@@ -3,7 +3,7 @@ use crate::transforms::{
     DownChainProtocol, TransformBuilder, TransformConfig, TransformContextConfig, UpChainProtocol,
 };
 use anyhow::{Result, anyhow};
-use serde::de::{Deserializer, MapAccess, SeqAccess, Visitor};
+use serde::de::{Deserializer, SeqAccess, Visitor};
 use serde::ser::{SerializeSeq, Serializer};
 use serde::{Deserialize, Serialize};
 use std::fmt::{self, Debug};
@@ -16,34 +16,18 @@ pub struct NamedTransformEntry {
 
 #[derive(Debug)]
 pub struct TransformChainConfig {
-    pub name: Option<String>,
     pub transforms: Vec<NamedTransformEntry>,
 }
 
 impl TransformChainConfig {
     pub fn new_unnamed(transforms: Vec<NamedTransformEntry>) -> Self {
-        TransformChainConfig {
-            name: None,
-            transforms,
-        }
-    }
-
-    pub fn new_named(name: String, transforms: Vec<NamedTransformEntry>) -> Self {
-        TransformChainConfig {
-            name: Some(name),
-            transforms,
-        }
+        TransformChainConfig { transforms }
     }
 
     pub async fn get_builder(
         &self,
         mut transform_context: TransformContextConfig,
     ) -> Result<TransformChainBuilder> {
-        let chain_name = self
-            .name
-            .clone()
-            .unwrap_or_else(|| transform_context.chain_name.clone());
-
         let mut builders: Vec<(Box<dyn TransformBuilder>, String)> = Vec::new();
         let mut upchain_protocol = transform_context.up_chain_protocol;
         for entry in &self.transforms {
@@ -70,15 +54,15 @@ impl TransformChainConfig {
                 DownChainProtocol::Terminating => upchain_protocol,
             }
         }
-        Ok(TransformChainBuilder::new(builders, chain_name.leak()))
+        Ok(TransformChainBuilder::new(
+            builders,
+            transform_context.chain_name.leak(),
+        ))
     }
 
     /// Recursively collects all chain names from this chain config and any nested sub-chains.
     pub fn collect_all_chain_names(&self) -> Vec<String> {
         let mut names = Vec::new();
-        if let Some(ref name) = self.name {
-            names.push(name.clone());
-        }
         for entry in &self.transforms {
             names.extend(entry.config.get_extra_chain_names(&entry.name));
             for sub_chain in entry.config.get_sub_chain_configs() {
@@ -103,9 +87,18 @@ impl TransformChainConfig {
 
             // Recurse into sub-chains. For unnamed sub-chains the chain name
             // is derived from the transform name at runtime, so use that here.
-            for sub_chain in entry.config.get_sub_chain_configs() {
-                let sub_chain_name = sub_chain.name.as_deref().unwrap_or(&entry.name);
-                errors.extend(sub_chain.validate_names(sub_chain_name));
+            let sub_chain_configs = entry.config.get_sub_chain_configs();
+            let extra_chain_names = entry.config.get_extra_chain_names(&entry.name);
+            if extra_chain_names.len() == sub_chain_configs.len() {
+                for (sub_chain, sub_chain_name) in
+                    sub_chain_configs.iter().zip(extra_chain_names.iter())
+                {
+                    errors.extend(sub_chain.validate_names(sub_chain_name));
+                }
+            } else {
+                for sub_chain in sub_chain_configs {
+                    errors.extend(sub_chain.validate_names(&entry.name));
+                }
             }
         }
 
@@ -157,7 +150,7 @@ impl<'de> Deserialize<'de> for TransformChainConfig {
     where
         D: Deserializer<'de>,
     {
-        deserializer.deserialize_any(TransformChainConfigVisitor)
+        deserializer.deserialize_seq(TransformChainConfigVisitor)
     }
 }
 
@@ -167,7 +160,7 @@ impl<'de> Visitor<'de> for TransformChainConfigVisitor {
     type Value = TransformChainConfig;
 
     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a list of named transforms or a map with 'name' and 'transforms'")
+        formatter.write_str("a list of named transforms")
     }
 
     fn visit_seq<S>(self, mut seq: S) -> std::result::Result<Self::Value, S::Error>
@@ -181,57 +174,6 @@ impl<'de> Visitor<'de> for TransformChainConfigVisitor {
             entries.push(entry);
         }
         Ok(TransformChainConfig {
-            name: None,
-            transforms: entries,
-        })
-    }
-
-    fn visit_map<M>(self, mut map: M) -> std::result::Result<Self::Value, M::Error>
-    where
-        M: MapAccess<'de>,
-    {
-        let mut name: Option<String> = None;
-        let mut transforms_value: Option<serde_yaml::Value> = None;
-
-        while let Some(key) = map.next_key::<String>()? {
-            match key.as_str() {
-                "name" => {
-                    name = Some(map.next_value()?);
-                }
-                "transforms" => {
-                    transforms_value = Some(map.next_value()?);
-                }
-                other => {
-                    return Err(serde::de::Error::unknown_field(
-                        other,
-                        &["name", "transforms"],
-                    ));
-                }
-            }
-        }
-
-        let name = name.ok_or_else(|| serde::de::Error::missing_field("name"))?;
-        let transforms_value =
-            transforms_value.ok_or_else(|| serde::de::Error::missing_field("transforms"))?;
-
-        let transforms_seq = match transforms_value {
-            serde_yaml::Value::Sequence(seq) => seq,
-            _ => {
-                return Err(serde::de::Error::custom(
-                    "'transforms' must be a list of transform entries",
-                ));
-            }
-        };
-
-        let mut entries = Vec::new();
-        for value in transforms_seq {
-            let entry =
-                deserialize_named_transform_entry(value).map_err(serde::de::Error::custom)?;
-            entries.push(entry);
-        }
-
-        Ok(TransformChainConfig {
-            name: Some(name),
             transforms: entries,
         })
     }