drift-core-python 0.1.5__tar.gz → 0.1.7__tar.gz

{drift_core_python-0.1.5 → drift_core_python-0.1.7}/Cargo.lock

@@ -106,7 +106,7 @@ dependencies = [
 
 [[package]]
 name = "drift-rust-core"
-version = "0.1.5"
+version = "0.1.7"
 dependencies = [
  "base64",
  "prost",
@@ -119,22 +119,24 @@ dependencies = [
 
 [[package]]
 name = "drift-rust-core-node"
-version = "0.1.5"
+version = "0.1.7"
 dependencies = [
  "drift-rust-core",
  "napi",
  "napi-build",
  "napi-derive",
  "serde_json",
+ "tusk-drift-schemas",
 ]
 
 [[package]]
 name = "drift-rust-core-python"
-version = "0.1.5"
+version = "0.1.7"
 dependencies = [
  "drift-rust-core",
  "pyo3",
  "serde_json",
+ "tusk-drift-schemas",
 ]
 
 [[package]]

{drift_core_python-0.1.5 → drift_core_python-0.1.7}/Cargo.toml

@@ -3,4 +3,7 @@ members = ["crates/drift-rust-core", "bindings/python"]
 resolver = "2"
 
 [workspace.package]
-version = "0.1.5"
+version = "0.1.7"
+
+[workspace.dependencies]
+tusk-drift-schemas = "0.1.30"

{drift_core_python-0.1.5 → drift_core_python-0.1.7}/PKG-INFO

@@ -1,5 +1,5 @@
 Metadata-Version: 2.4
 Name: drift-core-python
-Version: 0.1.5
+Version: 0.1.7
 Summary: Python bindings for drift-rust-core
 Requires-Python: >=3.9

{drift_core_python-0.1.5 → drift_core_python-0.1.7}/bindings/python/Cargo.toml

@@ -14,3 +14,4 @@ crate-type = ["cdylib"]
 drift-rust-core = { path = "../../crates/drift-rust-core" }
 pyo3 = { version = "0.27", features = ["extension-module", "abi3", "abi3-py39"] }
 serde_json = "1"
+tusk-drift-schemas.workspace = true

{drift_core_python-0.1.5 → drift_core_python-0.1.7}/bindings/python/src/api.rs

@@ -1,5 +1,6 @@
 use pyo3::prelude::*;
 use pyo3::types::{PyBytes, PyList};
+use tusk_drift_schemas::tusk::drift::core::v1::{PackageType, SpanKind, StatusCode};
 
 use crate::conversion::{
     json_value_to_py, py_any_to_optional_bytes, py_any_to_optional_json, py_to_json_value,
@@ -126,6 +127,17 @@ pub fn build_span_proto_bytes_pyobject(
     let output_value_json = py_any_to_optional_json(output_value)?;
     let input_struct_bytes = py_any_to_optional_bytes(input_value_proto_struct_bytes)?;
     let output_struct_bytes = py_any_to_optional_bytes(output_value_proto_struct_bytes)?;
+    let package_type = PackageType::try_from(package_type).map_err(|_| {
+        pyo3::exceptions::PyValueError::new_err(format!(
+            "invalid package_type enum: {package_type}"
+        ))
+    })?;
+    let kind = SpanKind::try_from(kind).map_err(|_| {
+        pyo3::exceptions::PyValueError::new_err(format!("invalid kind enum: {kind}"))
+    })?;
+    let status_code = StatusCode::try_from(status_code).map_err(|_| {
+        pyo3::exceptions::PyValueError::new_err(format!("invalid status_code enum: {status_code}"))
+    })?;
 
     drift_rust_core::build_span_proto_bytes(drift_rust_core::BuildSpanProtoInput {
         trace_id,

{drift_core_python-0.1.5 → drift_core_python-0.1.7}/crates/drift-rust-core/Cargo.toml

@@ -12,4 +12,4 @@ serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 sha2 = "0.10"
 base64 = "0.22"
-tusk-drift-schemas = "0.1.30"
+tusk-drift-schemas.workspace = true

{drift_core_python-0.1.5 → drift_core_python-0.1.7}/crates/drift-rust-core/src/export_request_proto.rs

@@ -60,4 +60,18 @@ mod tests {
         assert_eq!(decoded.spans.len(), 1);
         assert_eq!(decoded.spans[0].trace_id, "trace-1");
     }
+
+    #[test]
+    fn returns_error_when_span_bytes_are_invalid() {
+        let err = build_export_spans_request_bytes(
+            "svc-1",
+            "test",
+            "0.1.0",
+            "sdk-instance-1",
+            &[vec![0xff, 0x00, 0xab]],
+        )
+        .expect_err("invalid span bytes should fail");
+
+        assert!(matches!(err, CoreError::SerializationError(_)));
+    }
 }

{drift_core_python-0.1.5 → drift_core_python-0.1.7}/crates/drift-rust-core/src/hash.rs

@@ -45,3 +45,34 @@ fn sort_keys_recursively(v: &JsonValue) -> JsonValue {
         _ => v.clone(),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deterministic_hash_is_stable_across_object_key_order() {
+        let a = r#"{"z":1,"a":{"m":2,"b":[3,4]}}"#;
+        let b = r#"{"a":{"b":[3,4],"m":2},"z":1}"#;
+
+        let hash_a = deterministic_hash(a).expect("hash should succeed");
+        let hash_b = deterministic_hash(b).expect("hash should succeed");
+
+        assert_eq!(hash_a, hash_b);
+    }
+
+    #[test]
+    fn normalize_and_hash_returns_compact_json_and_sha256_hex() {
+        let input = "{ \"k\": \"v\", \"n\": 3 }";
+        let (normalized, hash) = normalize_and_hash(input).expect("operation should succeed");
+
+        assert_eq!(normalized, r#"{"k":"v","n":3}"#);
+        assert_eq!(hash.len(), 64);
+    }
+
+    #[test]
+    fn deterministic_hash_returns_invalid_json_error() {
+        let err = deterministic_hash("nope").expect_err("invalid json should fail");
+        assert!(matches!(err, CoreError::InvalidJson(_)));
+    }
+}

{drift_core_python-0.1.5 → drift_core_python-0.1.7}/crates/drift-rust-core/src/normalize.rs

@@ -16,3 +16,22 @@ pub(crate) fn json_roundtrip_normalize(v: &JsonValue) -> CoreResult<JsonValue> {
     let s = serde_json::to_string(v).map_err(|e| CoreError::SerializationError(e.to_string()))?;
     serde_json::from_str(&s).map_err(|e| CoreError::SerializationError(e.to_string()))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn normalize_json_compacts_valid_json() {
+        let input = "{\n  \"b\": 2,\n  \"a\": { \"x\": true }\n}";
+        let normalized = normalize_json(input).expect("normalization should succeed");
+
+        assert_eq!(normalized, r#"{"a":{"x":true},"b":2}"#);
+    }
+
+    #[test]
+    fn normalize_json_returns_invalid_json_error() {
+        let err = normalize_json("{not-valid-json").expect_err("invalid json should fail");
+        assert!(matches!(err, CoreError::InvalidJson(_)));
+    }
+}

drift_core_python-0.1.7/crates/drift-rust-core/src/payload.rs

@@ -0,0 +1,82 @@
+use serde_json::Value as JsonValue;
+
+use crate::error::{CoreError, CoreResult};
+use crate::normalize::parse_json;
+use crate::schema;
+use crate::types::{ExportPayloadResult, ExportPayloadValueResult};
+
+pub fn process_export_payload(
+    payload_json: &str,
+    schema_merges_json: Option<&str>,
+) -> CoreResult<ExportPayloadResult> {
+    let input = parse_json(payload_json)?;
+    let value_result = process_export_payload_value(&input, schema_merges_json)?;
+    let normalized_json = serde_json::to_string(&value_result.normalized_value)
+        .map_err(|e| CoreError::SerializationError(e.to_string()))?;
+    let decoded_json = serde_json::to_string(&value_result.decoded_value)
+        .map_err(|e| CoreError::SerializationError(e.to_string()))?;
+
+    Ok(ExportPayloadResult {
+        normalized_json,
+        decoded_json,
+        decoded_value_hash: value_result.decoded_value_hash,
+        decoded_schema_json: serde_json::to_string(&value_result.decoded_schema_value)
+            .map_err(|e| CoreError::SerializationError(e.to_string()))?,
+        decoded_schema_hash: value_result.decoded_schema_hash,
+        protobuf_struct_bytes: value_result.protobuf_struct_bytes,
+    })
+}
+
+pub fn process_export_payload_value(
+    payload_value: &JsonValue,
+    schema_merges_json: Option<&str>,
+) -> CoreResult<ExportPayloadValueResult> {
+    schema::process_export_payload_value(payload_value, schema_merges_json)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn process_export_payload_value_without_merges_keeps_decoded_equal_normalized() {
+        let payload = serde_json::json!({"k":"v","n":1});
+        let result = process_export_payload_value(&payload, None).expect("processing should work");
+
+        assert_eq!(result.decoded_value, result.normalized_value);
+        assert_eq!(result.decoded_schema_value["type"], serde_json::json!(6));
+        assert!(!result.protobuf_struct_bytes.is_empty());
+    }
+
+    #[test]
+    fn process_export_payload_value_applies_base64_and_json_decoding_merges() {
+        let payload = serde_json::json!({
+            "decoded_blob": "eyJrIjoidiJ9"
+        });
+        let merges = r#"{"decoded_blob":{"encoding":1,"decoded_type":1,"match_importance":0.75}}"#;
+
+        let result = process_export_payload_value(&payload, Some(merges))
+            .expect("processing with merges should work");
+
+        assert_eq!(
+            result.decoded_value["decoded_blob"]["k"],
+            serde_json::json!("v")
+        );
+        assert_eq!(
+            result.decoded_schema_value["properties"]["decoded_blob"]["encoding"],
+            serde_json::json!(1)
+        );
+        assert_eq!(
+            result.decoded_schema_value["properties"]["decoded_blob"]["decoded_type"],
+            serde_json::json!(1)
+        );
+    }
+
+    #[test]
+    fn process_export_payload_returns_error_for_invalid_merges_json() {
+        let payload = r#"{"k":"v"}"#;
+        let err = process_export_payload(payload, Some("{not-json"))
+            .expect_err("invalid merges json should fail");
+        assert!(matches!(err, CoreError::InvalidJson(_)));
+    }
+}

{drift_core_python-0.1.5 → drift_core_python-0.1.7}/crates/drift-rust-core/src/protobuf_struct.rs

@@ -67,3 +67,35 @@ fn json_to_protobuf_value(v: &JsonValue) -> Value {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use prost_types::value::Kind;
+
+    #[test]
+    fn object_to_protobuf_struct_preserves_top_level_fields() {
+        let payload = r#"{"n":1,"s":"x","b":true,"arr":[1,2],"obj":{"k":"v"},"nullv":null}"#;
+        let s = object_to_protobuf_struct(payload).expect("conversion should succeed");
+
+        assert_eq!(s.fields.len(), 6);
+        assert!(matches!(
+            s.fields.get("nullv").and_then(|v| v.kind.as_ref()),
+            Some(Kind::NullValue(_))
+        ));
+    }
+
+    #[test]
+    fn non_object_json_yields_empty_struct() {
+        let s = object_to_protobuf_struct("[1,2,3]").expect("conversion should succeed");
+        assert!(s.fields.is_empty());
+    }
+
+    #[test]
+    fn object_to_protobuf_struct_field_count_matches_field_total() {
+        let payload = r#"{"a":1,"b":2,"c":{"nested":3}}"#;
+        let count =
+            object_to_protobuf_struct_field_count(payload).expect("field count should succeed");
+        assert_eq!(count, 3);
+    }
+}

{drift_core_python-0.1.5 → drift_core_python-0.1.7}/crates/drift-rust-core/src/span_proto.rs

@@ -43,7 +43,7 @@ pub fn build_span_proto_bytes(input: BuildSpanProtoInput<'_>) -> CoreResult<Vec<
         package_name: input.package_name.to_string(),
         instrumentation_name: input.instrumentation_name.to_string(),
         submodule_name: input.submodule_name.to_string(),
-        package_type: input.package_type,
+        package_type: input.package_type as i32,
         input_value: Some(input_struct),
         output_value: Some(output_struct),
         input_schema: Some(json_schema_from_value(input.input_schema)),
@@ -52,9 +52,9 @@ pub fn build_span_proto_bytes(input: BuildSpanProtoInput<'_>) -> CoreResult<Vec<
         output_schema_hash: input.output_schema_hash.to_string(),
         input_value_hash: input.input_value_hash.to_string(),
         output_value_hash: input.output_value_hash.to_string(),
-        kind: input.kind,
+        kind: input.kind as i32,
         status: Some(SpanStatus {
-            code: input.status_code,
+            code: input.status_code as i32,
             message: input.status_message.to_string(),
         }),
         is_pre_app_start: input.is_pre_app_start,
@@ -123,6 +123,7 @@ fn json_schema_from_value(value: &JsonValue) -> JsonSchema {
 mod tests {
     use super::*;
     use crate::types::BuildSpanProtoInput;
+    use tusk_drift_schemas::tusk::drift::core::v1::{PackageType, SpanKind, StatusCode};
 
     #[test]
     fn build_span_proto_bytes_decodes_as_generated_span() {
@@ -140,16 +141,16 @@ mod tests {
             package_name: "http",
             instrumentation_name: "instr",
             submodule_name: "GET",
-            package_type: 1,
+            package_type: PackageType::Http,
             environment: Some("test"),
-            kind: 2,
+            kind: SpanKind::Server,
             input_schema: &input_schema,
             output_schema: &output_schema,
             input_schema_hash: "ih",
             output_schema_hash: "oh",
             input_value_hash: "ivh",
             output_value_hash: "ovh",
-            status_code: 1,
+            status_code: StatusCode::Ok,
             status_message: "ok",
             is_pre_app_start: false,
             is_root_span: true,
@@ -171,4 +172,45 @@ mod tests {
         assert_eq!(decoded.kind, 2);
         assert_eq!(decoded.environment.as_deref(), Some("test"));
     }
+
+    #[test]
+    fn returns_error_when_prebuilt_proto_struct_bytes_are_invalid() {
+        let input_schema = serde_json::json!({"type": 6, "properties": {}});
+        let output_schema = serde_json::json!({"type": 6, "properties": {}});
+
+        let err = build_span_proto_bytes(BuildSpanProtoInput {
+            trace_id: "trace-1",
+            span_id: "span-1",
+            parent_span_id: "",
+            name: "test-span",
+            package_name: "http",
+            instrumentation_name: "instr",
+            submodule_name: "GET",
+            package_type: PackageType::Http,
+            environment: Some("test"),
+            kind: SpanKind::Server,
+            input_schema: &input_schema,
+            output_schema: &output_schema,
+            input_schema_hash: "ih",
+            output_schema_hash: "oh",
+            input_value_hash: "ivh",
+            output_value_hash: "ovh",
+            status_code: StatusCode::Ok,
+            status_message: "ok",
+            is_pre_app_start: false,
+            is_root_span: true,
+            timestamp_seconds: 1,
+            timestamp_nanos: 2,
+            duration_seconds: 3,
+            duration_nanos: 4,
+            metadata: None,
+            input_value: None,
+            output_value: None,
+            input_value_proto_struct_bytes: Some(&[0xff, 0x00]),
+            output_value_proto_struct_bytes: None,
+        })
+        .expect_err("invalid struct bytes should fail");
+
+        assert!(matches!(err, CoreError::SerializationError(_)));
+    }
 }

{drift_core_python-0.1.5 → drift_core_python-0.1.7}/crates/drift-rust-core/src/types.rs

@@ -1,4 +1,5 @@
 use serde_json::Value as JsonValue;
+use tusk_drift_schemas::tusk::drift::core::v1::{PackageType, SpanKind, StatusCode};
 
 #[derive(Debug, Clone)]
 pub struct ExportPayloadResult {
@@ -28,16 +29,16 @@ pub struct BuildSpanProtoInput<'a> {
     pub package_name: &'a str,
     pub instrumentation_name: &'a str,
     pub submodule_name: &'a str,
-    pub package_type: i32,
+    pub package_type: PackageType,
     pub environment: Option<&'a str>,
-    pub kind: i32,
+    pub kind: SpanKind,
     pub input_schema: &'a JsonValue,
     pub output_schema: &'a JsonValue,
     pub input_schema_hash: &'a str,
     pub output_schema_hash: &'a str,
     pub input_value_hash: &'a str,
     pub output_value_hash: &'a str,
-    pub status_code: i32,
+    pub status_code: StatusCode,
     pub status_message: &'a str,
     pub is_pre_app_start: bool,
     pub is_root_span: bool,

{drift_core_python-0.1.5 → drift_core_python-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "drift-core-python"
-version = "0.1.5"
+version = "0.1.7"
 description = "Python bindings for drift-rust-core"
 requires-python = ">=3.9"
 

drift_core_python-0.1.5/crates/drift-rust-core/src/payload.rs

@@ -1,35 +0,0 @@
-use serde_json::Value as JsonValue;
-
-use crate::error::{CoreError, CoreResult};
-use crate::normalize::parse_json;
-use crate::schema;
-use crate::types::{ExportPayloadResult, ExportPayloadValueResult};
-
-pub fn process_export_payload(
-    payload_json: &str,
-    schema_merges_json: Option<&str>,
-) -> CoreResult<ExportPayloadResult> {
-    let input = parse_json(payload_json)?;
-    let value_result = process_export_payload_value(&input, schema_merges_json)?;
-    let normalized_json = serde_json::to_string(&value_result.normalized_value)
-        .map_err(|e| CoreError::SerializationError(e.to_string()))?;
-    let decoded_json = serde_json::to_string(&value_result.decoded_value)
-        .map_err(|e| CoreError::SerializationError(e.to_string()))?;
-
-    Ok(ExportPayloadResult {
-        normalized_json,
-        decoded_json,
-        decoded_value_hash: value_result.decoded_value_hash,
-        decoded_schema_json: serde_json::to_string(&value_result.decoded_schema_value)
-            .map_err(|e| CoreError::SerializationError(e.to_string()))?,
-        decoded_schema_hash: value_result.decoded_schema_hash,
-        protobuf_struct_bytes: value_result.protobuf_struct_bytes,
-    })
-}
-
-pub fn process_export_payload_value(
-    payload_value: &JsonValue,
-    schema_merges_json: Option<&str>,
-) -> CoreResult<ExportPayloadValueResult> {
-    schema::process_export_payload_value(payload_value, schema_merges_json)
-}