feat(thread-protocol): Extract lock mechanism (#1979)

The android sdk is going to start sending lock mechanism
as a part of the thread interface which we are going
to want to extract and store on events json.

![image
(2)](https://user-images.githubusercontent.com/63818634/228589578-de6aae22-7e38-4220-958a-c184fe421fc5.png)

closes getsentry/sentry#46510

Author: shruthilayaj

CHANGELOG.md

@@ -32,6 +32,7 @@ Metrics:
 - Allow monitor checkins to paass `monitor_config` for monitor upserts. ([#1962](https://github.com/getsentry/relay/pull/1962))
 - Changes how device class is determined for iPhone devices. Instead of checking processor frequency, the device model is mapped to a device class. ([#1970](https://github.com/getsentry/relay/pull/1970))
 - Don't sanitize transactions if no clustering rules exist and no UUIDs were scrubbed. ([#1976](https://github.com/getsentry/relay/pull/1976))
+- Add `thread.lock_mechanism` field to protocol. ([#1979](https://github.com/getsentry/relay/pull/1979))
 
 **Internal**:
 

relay-general/src/protocol/thread.rs

@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize, Serializer};
 use crate::processor::ProcessValue;
 use crate::protocol::{RawStacktrace, Stacktrace};
 use crate::types::{
-    Annotated, Empty, Error, FromValue, IntoValue, Object, SkipSerialization, Value,
+    Annotated, Empty, Error, ErrorKind, FromValue, IntoValue, Object, SkipSerialization, Value,
 };
 
 /// Represents a thread id.
@@ -69,6 +69,111 @@ impl Empty for ThreadId {
     }
 }
 
+/// Possible lock types responsible for a thread's blocked state
+#[derive(Debug, Copy, Clone, Eq, PartialEq, ProcessValue, Empty)]
+#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
+#[cfg_attr(feature = "jsonschema", schemars(rename_all = "lowercase"))]
+pub enum LockReasonType {
+    /// Thread is Runnable but holding a lock object (generic case).
+    Locked = 1,
+    /// Thread TimedWaiting in Object.wait() with a timeout.
+    Waiting = 2,
+    /// Thread TimedWaiting in Thread.sleep().
+    Sleeping = 4,
+    /// Thread Blocked on a monitor/shared lock.
+    Blocked = 8,
+    // This enum does not have a `fallback_variant` because we consider it unlikely to be extended. If it is,
+    // The error added to `Meta` will tell us to update this enum.
+}
+
+impl LockReasonType {
+    fn from_android_lock_reason_type(value: u64) -> Option<LockReasonType> {
+        Some(match value {
+            1 => LockReasonType::Locked,
+            2 => LockReasonType::Waiting,
+            4 => LockReasonType::Sleeping,
+            8 => LockReasonType::Blocked,
+            _ => return None,
+        })
+    }
+}
+
+impl FromValue for LockReasonType {
+    fn from_value(value: Annotated<Value>) -> Annotated<Self> {
+        match value {
+            Annotated(Some(Value::U64(val)), mut meta) => {
+                match LockReasonType::from_android_lock_reason_type(val) {
+                    Some(value) => Annotated(Some(value), meta),
+                    None => {
+                        meta.add_error(ErrorKind::InvalidData);
+                        meta.set_original_value(Some(val));
+                        Annotated(None, meta)
+                    }
+                }
+            }
+            Annotated(Some(Value::I64(val)), mut meta) => {
+                match LockReasonType::from_android_lock_reason_type(val as u64) {
+                    Some(value) => Annotated(Some(value), meta),
+                    None => {
+                        meta.add_error(ErrorKind::InvalidData);
+                        meta.set_original_value(Some(val));
+                        Annotated(None, meta)
+                    }
+                }
+            }
+            Annotated(None, meta) => Annotated(None, meta),
+            Annotated(Some(value), mut meta) => {
+                meta.add_error(Error::expected("lock reason type"));
+                meta.set_original_value(Some(value));
+                Annotated(None, meta)
+            }
+        }
+    }
+}
+
+impl IntoValue for LockReasonType {
+    fn into_value(self) -> Value {
+        Value::U64(self as u64)
+    }
+
+    fn serialize_payload<S>(&self, s: S, _behavior: SkipSerialization) -> Result<S::Ok, S::Error>
+    where
+        Self: Sized,
+        S: Serializer,
+    {
+        Serialize::serialize(&(*self as u64), s)
+    }
+}
+
+/// Represents an instance of a held lock (java monitor object) in a thread.
+#[derive(Clone, Debug, PartialEq, Empty, FromValue, IntoValue, ProcessValue)]
+#[cfg_attr(feature = "jsonschema", derive(JsonSchema))]
+pub struct LockReason {
+    /// Type of lock on the thread with available options being blocked, waiting, sleeping and locked.
+    #[metastructure(field = "type", required = "true")]
+    pub ty: Annotated<LockReasonType>,
+
+    /// Address of the java monitor object.
+    #[metastructure(skip_serialization = "empty")]
+    pub address: Annotated<String>,
+
+    /// Package name of the java monitor object.
+    #[metastructure(skip_serialization = "empty")]
+    pub package_name: Annotated<String>,
+
+    /// Class name of the java monitor object.
+    #[metastructure(skip_serialization = "empty")]
+    pub class_name: Annotated<String>,
+
+    /// Thread ID that's holding the lock.
+    #[metastructure(skip_serialization = "empty")]
+    pub thread_id: Annotated<ThreadId>,
+
+    /// Additional arbitrary fields for forwards compatibility.
+    #[metastructure(additional_properties)]
+    pub other: Object<Value>,
+}
+
 /// A process thread of an event.
 ///
 /// The Threads Interface specifies threads that were running at the time an event happened. These threads can also contain stack traces.
@@ -128,6 +233,10 @@ pub struct Thread {
     #[metastructure(skip_serialization = "empty")]
     pub state: Annotated<String>,
 
+    /// Represents an instance of a held lock (java monitor object) in a thread.
+    #[metastructure(skip_serialization = "empty")]
+    pub lock_reason: Annotated<LockReason>,
+
     /// Additional arbitrary fields for forwards compatibility.
     #[metastructure(additional_properties)]
     pub other: Object<Value>,
@@ -183,6 +292,7 @@ mod tests {
             current: Annotated::new(true),
             main: Annotated::new(true),
             state: Annotated::new("RUNNABLE".to_string()),
+            lock_reason: Annotated::empty(),
             other: {
                 let mut map = Map::new();
                 map.insert(
@@ -205,4 +315,54 @@ mod tests {
         assert_eq!(thread, Annotated::from_json(json).unwrap());
         assert_eq!(json, thread.to_json_pretty().unwrap());
     }
+
+    #[test]
+    fn test_thread_lock_reason_roundtrip() {
+        // stack traces are tested separately
+        let input = r#"{
+  "id": 42,
+  "name": "myname",
+  "crashed": true,
+  "current": true,
+  "main": true,
+  "state": "BLOCKED",
+  "lock_reason": {
+    "type": 1,
+    "package_name": "android.database.sqlite",
+    "class_name": "SQLiteConnection",
+    "thread_id": 2
+  },
+  "other": "value"
+}"#;
+        let thread = Annotated::new(Thread {
+            id: Annotated::new(ThreadId::Int(42)),
+            name: Annotated::new("myname".to_string()),
+            stacktrace: Annotated::empty(),
+            raw_stacktrace: Annotated::empty(),
+            crashed: Annotated::new(true),
+            current: Annotated::new(true),
+            main: Annotated::new(true),
+            state: Annotated::new("BLOCKED".to_string()),
+            lock_reason: Annotated::new(LockReason {
+                ty: Annotated::new(LockReasonType::Locked),
+                address: Annotated::empty(),
+                package_name: Annotated::new("android.database.sqlite".to_string()),
+                class_name: Annotated::new("SQLiteConnection".to_string()),
+                thread_id: Annotated::new(ThreadId::Int(2)),
+                other: Default::default(),
+            }),
+            other: {
+                let mut map = Map::new();
+                map.insert(
+                    "other".to_string(),
+                    Annotated::new(Value::String("value".to_string())),
+                );
+                map
+            },
+        });
+
+        assert_eq!(thread, Annotated::from_json(input).unwrap());
+
+        assert_eq!(input, thread.to_json_pretty().unwrap());
+    }
 }

relay-general/tests/snapshots/test_fixtures__event_schema.snap

@@ -2022,6 +2022,77 @@ expression: "relay_general::protocol::event_json_schema()"
         "fatal"
       ]
     },
+    "LockReason": {
+      "description": " Represents an instance of a held lock (java monitor object) in a thread.",
+      "anyOf": [
+        {
+          "type": "object",
+          "required": [
+            "type"
+          ],
+          "properties": {
+            "address": {
+              "description": " Address of the java monitor object.",
+              "default": null,
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "class_name": {
+              "description": " Class name of the java monitor object.",
+              "default": null,
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "package_name": {
+              "description": " Package name of the java monitor object.",
+              "default": null,
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "thread_id": {
+              "description": " Thread ID that's holding the lock.",
+              "default": null,
+              "anyOf": [
+                {
+                  "$ref": "#/definitions/ThreadId"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "type": {
+              "description": " Type of lock on the thread with available options being blocked, waiting, sleeping and locked.",
+              "anyOf": [
+                {
+                  "$ref": "#/definitions/LockReasonType"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            }
+          },
+          "additionalProperties": false
+        }
+      ]
+    },
+    "LockReasonType": {
+      "description": "Possible lock types responsible for a thread's blocked state",
+      "type": "string",
+      "enum": [
+        "locked",
+        "waiting",
+        "sleeping",
+        "blocked"
+      ]
+    },
     "LogEntry": {
       "description": " A log entry message.\n\n A log message is similar to the `message` attribute on the event itself but\n can additionally hold optional parameters.\n\n ```json\n {\n   \"message\": {\n     \"message\": \"My raw message with interpreted strings like %s\",\n     \"params\": [\"this\"]\n   }\n }\n ```\n\n ```json\n {\n   \"message\": {\n     \"message\": \"My raw message with interpreted strings like {foo}\",\n     \"params\": {\"foo\": \"this\"}\n   }\n }\n ```",
       "anyOf": [
@@ -3126,6 +3197,18 @@ expression: "relay_general::protocol::event_json_schema()"
                 }
               ]
             },
+            "lock_reason": {
+              "description": " Represents an instance of a held lock (java monitor object) in a thread.",
+              "default": null,
+              "anyOf": [
+                {
+                  "$ref": "#/definitions/LockReason"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
             "main": {
               "description": " A flag indicating whether the thread was responsible for rendering the user interface.",
               "default": null,