Update SDK and tracing (#194)

<!-- The PR description should answer 2 (maybe 3) important questions:
-->

### What
* Update sdk to 0.5.0
* Add visibility user to tracing spans

Author: codedmart

Cargo.lock

@@ -52,7 +52,7 @@ unused_async = "allow"
 # ndc-models was using version 0.1.2 but we needed rustls fix
 
 ndc-models = { git = "https://github.com/hasura/ndc-spec.git", tag = "v0.1.6" }
-ndc-sdk = { git = "https://github.com/hasura/ndc-sdk-rs.git", tag = "v0.4.0" }
+ndc-sdk = { git = "https://github.com/hasura/ndc-sdk-rs.git", tag = "v0.5.0" }
 ndc-test = { git = "https://github.com/hasura/ndc-spec.git", tag = "v0.1.6" }
 
 smol_str = "0.1"

Cargo.toml

@@ -62,7 +62,7 @@ pub async fn run(command: Command, context: Context<impl Environment>) -> anyhow
             binary_cli_manifest,
         } => initialize(with_metadata, context, binary_cli_manifest).await?,
         Command::Update { subcommand } => update(context, subcommand).await?,
-    };
+    }
     Ok(())
 }
 

crates/cli/src/lib.rs

@@ -195,7 +195,7 @@ async fn configure_stored_procedures(
                 &mut stored_procs_rows,
             )
             .await
-            .map_err(|e| Error::IntrospectionQueryExecutionError(format!("{:?}", e)))?;
+            .map_err(|e| Error::IntrospectionQueryExecutionError(format!("{e:?}")))?;
             let introspected_stored_procedures: Vec<introspection::IntrospectStoredProcedure> =
                 serde_json::from_slice(&stored_procs_rows)
                     .map_err(|e| Error::JsonDeserializationError(e.to_string()))?;
@@ -209,9 +209,6 @@ async fn configure_stored_procedures(
                     std::collections::btree_map::Entry::Occupied(mut e) => {
                         if config_options.overwrite_existing_stored_procedures {
                             e.insert(stored_procedure);
-                        } else {
-                            // do not overwrite the existing stored procedure
-                            continue;
                         }
                     }
                     std::collections::btree_map::Entry::Vacant(e) => {
@@ -262,7 +259,7 @@ pub async fn configure(
         &mut table_rows,
     )
     .await
-    .map_err(|e| Error::IntrospectionQueryExecutionError(format!("{:?}", e)))?;
+    .map_err(|e| Error::IntrospectionQueryExecutionError(format!("{e:?}")))?;
     let tables: Vec<introspection::IntrospectionTable> = serde_json::from_slice(&table_rows)
         .map_err(|e| Error::JsonDeserializationError(e.to_string()))?;
 
@@ -277,7 +274,7 @@ pub async fn configure(
         &mut types_rows,
     )
     .await
-    .map_err(|e| Error::IntrospectionQueryExecutionError(format!("{:?}", e)))?;
+    .map_err(|e| Error::IntrospectionQueryExecutionError(format!("{e:?}")))?;
     let type_names: Vec<TypeItem> = serde_json::from_slice(&types_rows)
         .map_err(|e| Error::JsonDeserializationError(e.to_string()))?;
 
@@ -457,7 +454,7 @@ fn get_aggregate_functions_for_type(
                 return_type: metadata::ScalarType(precise_return_type.to_string()),
             },
         );
-    };
+    }
 
     aggregate_functions.insert(
         AggregateFunctionName::new("COUNT_BIG".to_string().into()),

crates/configuration/src/version1.rs

@@ -36,18 +36,16 @@ impl<Env: Environment> SQLServerSetup<Env> {
 }
 
 #[async_trait]
-impl<Env: Environment + Send + Sync> connector::ConnectorSetup for SQLServerSetup<Env> {
+impl<Env: Environment + Send + Sync + 'static> connector::ConnectorSetup for SQLServerSetup<Env> {
     type Connector = SQLServer;
 
     /// Validate the raw configuration provided by the user,
     /// returning a configuration error or a validated [`Connector::Configuration`].
     async fn parse_configuration(
         &self,
-        configuration_dir: impl AsRef<Path> + Send,
+        configuration_dir: &Path,
     ) -> Result<<Self::Connector as connector::Connector>::Configuration> {
-        let configuration_file = configuration_dir
-            .as_ref()
-            .join(configuration::CONFIGURATION_FILENAME);
+        let configuration_file = configuration_dir.join(configuration::CONFIGURATION_FILENAME);
         let configuration_file_contents =
             fs::read_to_string(&configuration_file).await.map_err(|_| {
                 connector::ParseError::CouldNotFindConfiguration(configuration_file.clone())
@@ -103,22 +101,20 @@ impl<Env: Environment + Send + Sync> connector::ConnectorSetup for SQLServerSetu
             }
             configuration::Error::IoError(inner) => connector::ParseError::IoError(inner),
             configuration::Error::IoErrorButStringified(inner) => {
-                std::io::Error::new(std::io::ErrorKind::Other, inner).into()
-            }
-            configuration::Error::ConnectionPoolError(inner) => {
-                std::io::Error::new(std::io::ErrorKind::Other, inner).into()
+                std::io::Error::other(inner).into()
             }
+            configuration::Error::ConnectionPoolError(inner) => std::io::Error::other(inner).into(),
             configuration::Error::GetConnectionFromPool(inner) => {
-                std::io::Error::new(std::io::ErrorKind::Other, inner).into()
+                std::io::Error::other(inner).into()
             }
             configuration::Error::JsonDeserializationError(inner) => {
-                connector::ParseError::from(std::io::Error::new(std::io::ErrorKind::Other, inner))
+                connector::ParseError::from(std::io::Error::other(inner))
             }
             configuration::Error::IntrospectionQueryExecutionError(inner) => {
-                connector::ParseError::from(std::io::Error::new(std::io::ErrorKind::Other, inner))
+                connector::ParseError::from(std::io::Error::other(inner))
             }
             configuration::Error::StoredProcedureIntrospectionError(inner) => {
-                connector::ParseError::from(std::io::Error::new(std::io::ErrorKind::Other, inner))
+                connector::ParseError::from(std::io::Error::other(inner))
             }
         })?;
 

crates/ndc-sqlserver/src/connector.rs

@@ -63,7 +63,7 @@ pub async fn explain(
 
         Ok(response)
     }
-    .instrument(info_span!("/explain"))
+    .instrument(info_span!("Explain explain", internal.visibility = "user"))
     .await
 }
 

crates/ndc-sqlserver/src/explain.rs

@@ -50,7 +50,7 @@ pub async fn mutation(
 
         Ok(result)
     }
-    .instrument(info_span!("/mutation"))
+    .instrument(info_span!("Execute mutation"))
     .await;
 
     timer.complete_with(result)

crates/ndc-sqlserver/src/mutation.rs

@@ -167,8 +167,8 @@ fn make_procedure_type(
 /// Each native mutation creates two objects:
 /// 1. Object with name `{native_mutation_name}_response`, this object
 ///    will contain two fields:
-///         a. affected_rows: int - The rows affected by the native mutation.
-///         b. returning: `{native_mutation_name}` - Data returned by the native mutation.
+///    a. affected_rows: int - The rows affected by the native mutation.
+///    b. returning: `{native_mutation_name}` - Data returned by the native mutation.
 /// 2. Object with name `{native_mutation_name}` whose fields will
 ///    contain the fields specified in the `columns`.
 fn get_native_mutations_schema(
@@ -275,7 +275,7 @@ fn get_stored_procedures_schema(
                 return Err(connector::ErrorResponse::from_error(Box::new(
                     SchemaError::DuplicateObject(object_type_name),
                 )));
-            };
+            }
 
             let stored_proc_schema = models::ProcedureInfo {
                 name: proc_name.to_string().into(),

crates/ndc-sqlserver/src/schema.rs

@@ -122,12 +122,12 @@ pub async fn create_router(connection_uri: &str) -> axum::Router {
     let setup = connector::SQLServerSetup::new(environment);
 
     // initialise server state with the static configuration.
-    let state = ndc_sdk::default_main::init_server_state(setup, test_deployment_file)
+    let state = ndc_sdk::state::init_server_state(setup, &test_deployment_file)
         .await
         .unwrap();
 
     // create a fresh client
-    ndc_sdk::default_main::create_router(state, None)
+    ndc_sdk::default_main::create_router(state, None, None)
 }
 
 /// Make a single request against a new server, and get the response.

crates/ndc-sqlserver/tests/common/helpers.rs

@@ -179,7 +179,7 @@ impl Timer {
             Err(_) => {
                 self.0.stop_and_discard();
             }
-        };
+        }
         result
     }
 }
@@ -201,85 +201,85 @@ impl std::error::Error for Error {}
 #[derive(Debug, Clone)]
 pub struct ErrorMetrics {
     /// the connector received an invalid request.
-    invalid_request_total: IntCounter,
+    invalid_request: IntCounter,
     /// the connector received a request using capabilities it does not support.
-    unsupported_capability_total: IntCounter,
+    unsupported_capability: IntCounter,
     /// the connector could not fulfill a request because it does not support
     /// certain features (which are not described as capabilities).
-    unsupported_feature_total: IntCounter,
+    unsupported_feature: IntCounter,
     /// the connector had an internal error.
-    connector_error_total: IntCounter,
+    connector_error: IntCounter,
     /// the database emmited an error.
-    database_error_total: IntCounter,
+    database_error: IntCounter,
     /// we failed to acquire a database connection from the pool
-    connection_acquisition_error_total: IntCounter,
+    connection_acquisition_error: IntCounter,
 }
 
 impl ErrorMetrics {
     /// Set up counters and gauges used to produce Prometheus metrics
     pub fn initialize(metrics_registry: &mut prometheus::Registry) -> Result<Self, Error> {
-        let invalid_request_total = add_int_counter_metric(
+        let invalid_request = add_int_counter_metric(
             metrics_registry,
-            "ndc_sqlserver_error_invalid_request_total_count",
+            "ndc_sqlserver_error_invalid_request_count",
             "Total number of invalid requests encountered.",
         )?;
 
-        let unsupported_capability_total = add_int_counter_metric(
+        let unsupported_capability = add_int_counter_metric(
             metrics_registry,
-            "ndc_sqlserver_error_unsupported_capability_total_count",
+            "ndc_sqlserver_error_unsupported_capability_count",
             "Total number of invalid requests with unsupported capabilities encountered.",
         )?;
 
-        let unsupported_feature_total = add_int_counter_metric(
+        let unsupported_feature = add_int_counter_metric(
             metrics_registry,
-            "ndc_sqlserver_error_unsupported_capabilities_total_count",
+            "ndc_sqlserver_error_unsupported_capabilities_count",
             "Total number of invalid requests with unsupported capabilities encountered.",
         )?;
 
-        let connector_error_total = add_int_counter_metric(
+        let connector_error = add_int_counter_metric(
             metrics_registry,
-            "ndc_sqlserver_error_connector_error_total_count",
+            "ndc_sqlserver_error_connector_error_count",
             "Total number of requests failed due to an internal conenctor error.",
         )?;
 
-        let database_error_total = add_int_counter_metric(
+        let database_error = add_int_counter_metric(
             metrics_registry,
-            "ndc_sqlserver_error_database_error_total_count",
+            "ndc_sqlserver_error_database_error_count",
             "Total number of requests failed due to a database error.",
         )?;
 
-        let connection_acquisition_error_total = add_int_counter_metric(
+        let connection_acquisition_error = add_int_counter_metric(
             metrics_registry,
-            "ndc_sqlserver_error_connection_acquisition_error_total_count",
+            "ndc_sqlserver_error_connection_acquisition_error_count",
             "Total number of failures to acquire a database connection.",
         )?;
 
         Ok(ErrorMetrics {
-            invalid_request_total,
-            unsupported_capability_total,
-            unsupported_feature_total,
-            connector_error_total,
-            database_error_total,
-            connection_acquisition_error_total,
+            invalid_request,
+            unsupported_capability,
+            unsupported_feature,
+            connector_error,
+            database_error,
+            connection_acquisition_error,
         })
     }
 
     pub fn record_invalid_request(&self) {
-        self.invalid_request_total.inc();
+        self.invalid_request.inc();
     }
     pub fn record_unsupported_capability(&self) {
-        self.unsupported_capability_total.inc();
+        self.unsupported_capability.inc();
     }
     pub fn record_unsupported_feature(&self) {
-        self.unsupported_feature_total.inc();
+        self.unsupported_feature.inc();
     }
     pub fn record_connector_error(&self) {
-        self.connector_error_total.inc();
+        self.connector_error.inc();
     }
     pub fn record_database_error(&self) {
-        self.database_error_total.inc();
+        self.database_error.inc();
     }
     pub fn record_connection_acquisition_error(&self) {
-        self.connection_acquisition_error_total.inc()
+        self.connection_acquisition_error.inc()
     }
 }