feat: Add tracing support and configurable logging initialization

### **Summary**
This PR introduces comprehensive tracing support alongside the existing env_logger functionality, while making logging initialization configurable and event logging optional.

### **Key Features Added**

#### **🔧 New Feature Flags**
- **`tracing`**: Enables tracing/tracing-subscriber integration as an alternative to env_logger
- **`env_logger`**: Now an optional feature (still enabled by default for backward compatibility)
- **`log`**: Independent log feature flag that controls log statement generation in generated code and the availability of re-exported `log` crate

#### **📝 New Macro Parameters**
- **`log_init = function_name`**: Allows custom log initialization functions instead of relying on defaults
- **`event_logging = bool`**: Controls whether Lambda event payloads are logged (now defaults to `false` for better security)

#### **🚀 Tracing Integration**
- Adds `#[tracing::instrument]` attributes to generated handler functions
- Configures structured JSON logging by default
- Includes request ID and operation name in trace spans
- Aimed at replacing the existing env_logger setup when enabled (but both features can be enabled together)

### **Technical Changes**

#### **Architecture**
- **Feature-aware code generation**: Proc macro now conditionally generates logging code based on enabled features
- **Flexible initialization**: Supports custom logging setup functions with compile-time signature validation
- **Conditional compilation**: Uses cfg attributes to include only relevant logging dependencies

#### **Default Behavior Changes**
- Event payload logging (the event received by the Lambda function) is now disabled by default for security reasons. It must be explicitly enabled by the new `event_logging = bool` macro option.
- When event logging is enabled, events are logged at `debug` level instead of `info`

### **Breaking Changes**
- **Event Logging**: The full dump of the event payload received by the lambda function was always performed, it is now disabled by default (can be re-enabled with `event_logging = true`)

### **Backward Compatibility**
- Default feature set remains `["env_logger"]` ensuring existing code continues to work
- All existing macro parameters and functionality preserved
- Generated code structure unchanged for existing feature combinations

### **Examples Usage**

```rust
// Custom log initialization
appsync_lambda_main!("schema.graphql", log_init = my_custom_logger);

// Enable event logging for debugging
appsync_lambda_main!("schema.graphql", event_logging = true);
```

Author: JeremieRodon

Cargo.lock

@@ -28,13 +28,20 @@ tokio = { version = "1", features = ["macros"] }
 lambda_runtime = "1.0"
 aws-config = { version = "1.5", features = ["behavior-version-latest"] }
 aws-smithy-types = "1.3"
-log = "0.4"
-env_logger = "0.11"
 thiserror = "1.0"
 uuid = { version = "1.11", features = ["v4"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 
+# Default Lambda logging is based on log/env_logger
+log = "0.4"
+env_logger = "0.11"
+
+# Alternatively, a feature allow the use of tracing/tracing-subscriber
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["json", "env-filter"] }
+
+
 # Proc-macro crate dependencies
 syn = { version = "2.0", default-features = false, features = [
     "parsing",

Cargo.toml

@@ -21,8 +21,15 @@ proc-macro2 = { workspace = true }
 graphql-parser = { workspace = true }
 
 [dev-dependencies]
-lambda-appsync = { path = "../lambda-appsync" }
+lambda-appsync = { path = "../lambda-appsync", default-features = false, features = ["log", "env_logger", "tracing"] }
+tracing = { workspace = true }
 aws-sdk-s3 = { workspace = true }
 aws-sdk-dynamodb = { workspace = true }
 serde = { workspace = true }
 trybuild = { workspace = true }
+
+[features]
+default = ["log", "env_logger", "tracing"]
+log = []
+env_logger = []
+tracing = []

lambda-appsync-proc/Cargo.toml

@@ -971,7 +971,16 @@ impl GraphQLSchema {
         let subscription_field_execute_match_arm = self
             .subscriptions
             .execute_match_arm_iter(OperationKind::Subscription);
+
         let span = current_span();
+
+        #[allow(unused_mut)]
+        let mut log_lines = proc_macro2::TokenStream::new();
+        #[cfg(feature = "log")]
+        log_lines.extend(quote_spanned! {span=>
+            ::lambda_appsync::log::error!("{e}");
+        });
+
         tokens.extend(quote_spanned! {span=>
             impl Operation {
                 async fn execute(self,
@@ -980,7 +989,7 @@ impl GraphQLSchema {
                     match self._execute(event).await {
                         ::core::result::Result::Ok(v) => v.into(),
                         ::core::result::Result::Err(e) => {
-                            ::lambda_appsync::log::error!("{e}");
+                            #log_lines
                             e.into()
                         }
                     }