Fall back to system_health/event_file when querying deadlocks (#19189)

* query with target

* Fall back to system_health event_file if datadog XE doesn't exist

* parameter

* Fall back to system_health/event_file when querying deadlocks

* relnote

* linter

Author: nenadnoveljic

sqlserver/changelog.d/19189.changed

@@ -0,0 +1 @@
+Fall back to ``system_health/event_file`` when querying deadlocks if `datadog` XE session wasn't created.

sqlserver/datadog_checks/sqlserver/database_metrics/xe_session_metrics.py

@@ -6,6 +6,9 @@
 
 from .base import SqlserverDatabaseMetricsBase
 
+XE_RING_BUFFER = "ring_buffer"
+XE_EVENT_FILE = "event_file"
+
 XE_SESSION_STATUS_QUERY = {
     "name": "sys.dm_xe_sessions",
     "query": """SELECT

sqlserver/datadog_checks/sqlserver/deadlocks.py

@@ -11,6 +11,7 @@
 from datadog_checks.base.utils.tracking import tracked_method
 from datadog_checks.sqlserver.config import SQLServerConfig
 from datadog_checks.sqlserver.const import STATIC_INFO_ENGINE_EDITION, STATIC_INFO_VERSION
+from datadog_checks.sqlserver.database_metrics.xe_session_metrics import XE_EVENT_FILE, XE_RING_BUFFER
 from datadog_checks.sqlserver.queries import (
     DEADLOCK_TIMESTAMP_ALIAS,
     DEADLOCK_XML_ALIAS,
@@ -53,6 +54,7 @@ def __init__(self, check, config: SQLServerConfig):
         self.collection_interval = config.deadlocks_config.get("collection_interval", DEFAULT_COLLECTION_INTERVAL)
         self._force_convert_xml_to_str = False
         self._xe_session_name = None
+        self._xe_session_target = None
         super(Deadlocks, self).__init__(
             check,
             run_sync=True,
@@ -134,14 +136,24 @@ def _set_xe_session_name(self):
                     if not rows:
                         raise NoXESessionError(NO_XE_SESSION_ERROR)
                     xe_system_found = False
+                    xe_system_xe_file_found = False
                     for row in rows:
-                        if (session := row[0]) in (XE_SESSION_DATADOG):
+                        (session, target) = row
+                        if session in (XE_SESSION_DATADOG):
                             self._xe_session_name = session
+                            self._xe_session_target = target
                             return
                         if session == XE_SESSION_SYSTEM:
                             xe_system_found = True
+                            if target == XE_EVENT_FILE:
+                                xe_system_xe_file_found = True
+
                     if xe_system_found:
                         self._xe_session_name = XE_SESSION_SYSTEM
+                        if xe_system_xe_file_found:
+                            self._xe_session_target = XE_EVENT_FILE
+                        else:
+                            self._xe_session_target = XE_RING_BUFFER
                         return
         raise NoXESessionError(NO_XE_SESSION_ERROR)
 
@@ -152,15 +164,19 @@ def _query_deadlocks(self):
             except NoXESessionError as e:
                 self._log.error(str(e))
                 return
-            self._log.info(f'Using XE session {self._xe_session_name} to collect deadlocks')
+            self._log.info(
+                f'Using XE session [{self._xe_session_name}], target [{self._xe_session_target}] to collect deadlocks'
+            )
 
         with self._check.connection.open_managed_default_connection(key_prefix=self._conn_key_prefix):
             with self._check.connection.get_managed_cursor(key_prefix=self._conn_key_prefix) as cursor:
                 convert_xml_to_str = False
                 if self._force_convert_xml_to_str or self._get_connector() == "adodbapi":
                     convert_xml_to_str = True
                 query = get_deadlocks_query(
-                    convert_xml_to_str=convert_xml_to_str, xe_session_name=self._xe_session_name
+                    convert_xml_to_str=convert_xml_to_str,
+                    xe_session_name=self._xe_session_name,
+                    xe_target_name=self._xe_session_target,
                 )
                 lookback = self._get_lookback_seconds()
                 self._log.debug(

sqlserver/datadog_checks/sqlserver/queries.py

@@ -2,6 +2,7 @@
 # All rights reserved
 # Licensed under a 3-clause BSD style license (see LICENSE)
 
+from datadog_checks.sqlserver.database_metrics.xe_session_metrics import XE_RING_BUFFER
 
 DB_QUERY = """
 SELECT
@@ -135,22 +136,21 @@
 XE_SESSION_SYSTEM = "system_health"
 XE_SESSIONS_QUERY = f"""
 SELECT
-    s.name AS session_name
+    s.name AS session_name, t.target_name AS target_name
 FROM
     sys.dm_xe_sessions s
 JOIN
     sys.dm_xe_session_targets t
     ON s.address = t.event_session_address
 WHERE
-    t.target_name = 'ring_buffer'
-    AND s.name IN ('{XE_SESSION_DATADOG}', '{XE_SESSION_SYSTEM}');
+    s.name IN ('{XE_SESSION_DATADOG}', '{XE_SESSION_SYSTEM}');
 """
 
 DEADLOCK_TIMESTAMP_ALIAS = "timestamp"
 DEADLOCK_XML_ALIAS = "event_xml"
 
 
-def get_deadlocks_query(convert_xml_to_str=False, xe_session_name="datadog"):
+def get_deadlocks_query(convert_xml_to_str=False, xe_session_name=XE_SESSION_DATADOG, xe_target_name=XE_RING_BUFFER):
     """
     Construct the query to fetch deadlocks from the system_health extended event session
     :param convert_xml_to_str: Whether to convert the XML to a string. This option is for MSOLEDB drivers
@@ -161,16 +161,27 @@ def get_deadlocks_query(convert_xml_to_str=False, xe_session_name="datadog"):
     if convert_xml_to_str:
         xml_expression = "CAST(xdr.query('.') AS NVARCHAR(MAX))"
 
-    return f"""
-    SELECT TOP(?) xdr.value('@timestamp', 'datetime') AS [{DEADLOCK_TIMESTAMP_ALIAS}],
-        {xml_expression} AS [{DEADLOCK_XML_ALIAS}]
+    if xe_target_name == XE_RING_BUFFER:
+        return f"""SELECT TOP(?) xdr.value('@timestamp', 'datetime') AS [{DEADLOCK_TIMESTAMP_ALIAS}],
+            {xml_expression} AS [{DEADLOCK_XML_ALIAS}]
     FROM (SELECT CAST([target_data] AS XML) AS Target_Data
                 FROM sys.dm_xe_session_targets AS xt
                 INNER JOIN sys.dm_xe_sessions AS xs ON xs.address = xt.event_session_address
                 WHERE xs.name = N'{xe_session_name}'
-                AND xt.target_name = N'ring_buffer'
+                AND xt.target_name = N'{XE_RING_BUFFER}'
         ) AS XML_Data
     CROSS APPLY Target_Data.nodes('RingBufferTarget/event[@name="xml_deadlock_report"]') AS XEventData(xdr)
     WHERE xdr.value('@timestamp', 'datetime')
         >= DATEADD(SECOND, ?, TODATETIMEOFFSET(GETDATE(), DATEPART(TZOFFSET, SYSDATETIMEOFFSET())) AT TIME ZONE 'UTC')
     ;"""
+
+    return f"""SELECT TOP(?)
+event_data AS [{DEADLOCK_XML_ALIAS}],
+CONVERT(xml, event_data).value('(event[@name="xml_deadlock_report"]/@timestamp)[1]','datetime')
+    AS [{DEADLOCK_TIMESTAMP_ALIAS}]
+FROM
+sys.fn_xe_file_target_read_file
+('system_health*.xel', null, null, null)
+WHERE object_name like 'xml_deadlock_report'
+  and CONVERT(xml, event_data).value('(event[@name="xml_deadlock_report"]/@timestamp)[1]','datetime')
+    >= DATEADD(SECOND, ?, TODATETIMEOFFSET(GETDATE(), DATEPART(TZOFFSET, SYSDATETIMEOFFSET())) AT TIME ZONE 'UTC');"""

sqlserver/tests/test_deadlocks.py

@@ -16,13 +16,18 @@
 from mock import patch
 
 from datadog_checks.sqlserver import SQLServer
+from datadog_checks.sqlserver.database_metrics.xe_session_metrics import XE_EVENT_FILE, XE_RING_BUFFER
 from datadog_checks.sqlserver.deadlocks import (
     PAYLOAD_QUERY_SIGNATURE,
     PAYLOAD_TIMESTAMP,
-    XE_SESSION_DATADOG,
     Deadlocks,
 )
-from datadog_checks.sqlserver.queries import DEADLOCK_TIMESTAMP_ALIAS, DEADLOCK_XML_ALIAS
+from datadog_checks.sqlserver.queries import (
+    DEADLOCK_TIMESTAMP_ALIAS,
+    DEADLOCK_XML_ALIAS,
+    XE_SESSION_DATADOG,
+    XE_SESSION_SYSTEM,
+)
 
 from .common import CHECK_NAME
 
@@ -137,9 +142,18 @@ def _create_deadlock(dd_environment, dbm_instance):
 @pytest.mark.usefixtures('dd_environment')
 @pytest.mark.usefixtures('_create_deadlock')
 @pytest.mark.parametrize("convert_xml_to_str", [False, True])
-def test_deadlocks(aggregator, dd_run_check, dbm_instance, convert_xml_to_str):
+@pytest.mark.parametrize(
+    "xe_session_name, xe_session_target",
+    [
+        [XE_SESSION_DATADOG, XE_RING_BUFFER],
+        [XE_SESSION_SYSTEM, XE_EVENT_FILE],
+    ],
+)
+def test_deadlocks(aggregator, dd_run_check, dbm_instance, convert_xml_to_str, xe_session_name, xe_session_target):
     check = SQLServer(CHECK_NAME, {}, [dbm_instance])
     check.deadlocks._force_convert_xml_to_str = convert_xml_to_str
+    check.deadlocks._xe_session_name = xe_session_name
+    check.deadlocks._xe_session_target = xe_session_target
 
     dbm_instance['dbm_enabled'] = True
     deadlock_payloads = _run_check_and_get_deadlock_payloads(dd_run_check, check, aggregator)