Feat: If the 'tracing' feature is enabled, the default generated batch handler ensures to spawn each child task with a dedicated span. It is important for scenarios where the sub task should be related to the overall application run, which should be desired most of the time. Disabling the 'tracing' feature will prevent this behavior. Alternatively users can always overwrite the handler

Author: JeremieRodon

lambda-appsync-proc/src/internal/make_appsync/make_handlers.rs

@@ -88,15 +88,42 @@ impl ToTokens for MakeHandlers {
         let operation = &self.operation_type;
         let mut batch_handler = TokenStream2::new();
         if self.batch {
+            let spawn_code = if cfg!(feature = "tracing") {
+                quote! {
+                    use ::tracing::Instrument;
+                    let handles = events
+                        .into_iter()
+                        .enumerate()
+                        .map(|(index, event)| {
+                            let operation = event.info.operation;
+                            ::lambda_appsync::tokio::spawn(
+                                Self::appsync_handler(event).instrument(
+                                    ::tracing::info_span!(
+                                        "AppsyncEvent",
+                                        "otel.name"=format!("AppsyncEvent #{index}"),
+                                        batch_index=index,
+                                        ?operation
+                                    )
+                                )
+                            )
+                        })
+                        .collect::<::std::vec::Vec<_>>();
+                }
+            } else {
+                quote! {
+                    let handles = events
+                        .into_iter()
+                        .map(|event| ::lambda_appsync::tokio::spawn(Self::appsync_handler(event)))
+                        .collect::<::std::vec::Vec<_>>();
+                }
+            };
             batch_handler.extend(quote! {
                 #[doc = "Handles a batch of [lambda_appsync::AppsyncEvent<Operation>] concurrently."]
                 async fn appsync_batch_handler(
                     events: ::std::vec::Vec<::lambda_appsync::AppsyncEvent<#operation>>
                 ) -> ::std::vec::Vec<::lambda_appsync::AppsyncResponse> {
-                    let handles = events
-                        .into_iter()
-                        .map(|e| ::lambda_appsync::tokio::spawn(Self::appsync_handler(e)))
-                        .collect::<::std::vec::Vec<_>>();
+
+                    #spawn_code
 
                     let mut results = ::std::vec::Vec::new();
                     for h in handles {
@@ -127,6 +154,19 @@ impl ToTokens for MakeHandlers {
                     event.info.operation.execute(event)
                 }
             }
+        } else if cfg!(feature = "tracing") {
+            quote! {
+                async fn appsync_handler(event: ::lambda_appsync::AppsyncEvent<#operation>) -> ::lambda_appsync::AppsyncResponse {
+                    let operation = event.info.operation;
+                    event.info.operation.execute(event).instrument(
+                        ::tracing::info_span!(
+                            "AppsyncEvent",
+                            "otel.name"=format!("AppsyncEvent"),
+                            ?operation
+                        )
+                    ).await
+                }
+            }
         } else {
             quote! {
                 async fn appsync_handler(event: ::lambda_appsync::AppsyncEvent<#operation>) -> ::lambda_appsync::AppsyncResponse {