Expose capture_parameters in pymssql instrumentation

instrumentation/opentelemetry-instrumentation-pymssql/src/opentelemetry/instrumentation/pymssql/__init__.py

@@ -45,6 +45,7 @@
 The `instrument` method accepts the following keyword args:
 
 * tracer_provider (``TracerProvider``) - an optional tracer provider
+* capture_parameters (``bool``) - enable the capture of query parameters
 
 For example:
 
@@ -55,6 +56,12 @@
     from opentelemetry.trace import NoOpTracerProvider
 
     PyMSSQLInstrumentor().instrument(tracer_provider=NoOpTracerProvider())
+
+.. code:: python
+
+    from opentelemetry.instrumentation.pymssql import PyMSSQLInstrumentor
+
+    PyMSSQLInstrumentor().instrument(capture_parameters=True)
 """
 
 from __future__ import annotations
@@ -157,6 +164,7 @@ def _instrument(self, **kwargs):
         https://github.com/pymssql/pymssql/
         """
         tracer_provider = kwargs.get("tracer_provider")
+        capture_parameters = kwargs.get("capture_parameters", False)
 
         dbapi.wrap_connect(
             __name__,
@@ -169,20 +177,25 @@ def _instrument(self, **kwargs):
             # instead, we get the attributes from the connect method (which is done
             # via PyMSSQLDatabaseApiIntegration.wrapped_connection)
             db_api_integration_factory=_PyMSSQLDatabaseApiIntegration,
+            capture_parameters=capture_parameters,
         )
 
     def _uninstrument(self, **kwargs):
         """ "Disable pymssql instrumentation"""
         dbapi.unwrap_connect(pymssql, "connect")
 
     @staticmethod
-    def instrument_connection(connection, tracer_provider=None):
+    def instrument_connection(
+        connection, tracer_provider=None, capture_parameters=False
+    ):
         """Enable instrumentation in a pymssql connection.
 
         Args:
             connection: The connection to instrument.
             tracer_provider: The optional tracer provider to use. If omitted
                 the current globally configured one is used.
+            capture_parameters: Configure if db.statement.parameters should
+                be captured.
 
         Returns:
             An instrumented connection.
@@ -195,6 +208,7 @@ def instrument_connection(connection, tracer_provider=None):
             version=__version__,
             tracer_provider=tracer_provider,
             db_api_integration_factory=_PyMSSQLDatabaseApiIntegration,
+            capture_parameters=capture_parameters,
         )
 
     @staticmethod

instrumentation/opentelemetry-instrumentation-pymssql/tests/test_pymssql_integration.py

@@ -98,6 +98,26 @@ def test_instrumentor(self):
         spans_list = self.memory_exporter.get_finished_spans()
         self.assertEqual(len(spans_list), 1)
 
+    @patch("opentelemetry.instrumentation.pymssql.dbapi")
+    def test_instrumentor_forwards_capture_parameters_default(
+        self, mock_dbapi
+    ):
+        PyMSSQLInstrumentor().instrument()
+
+        self.assertIs(
+            mock_dbapi.wrap_connect.call_args.kwargs["capture_parameters"],
+            False,
+        )
+
+    @patch("opentelemetry.instrumentation.pymssql.dbapi")
+    def test_instrumentor_forwards_capture_parameters(self, mock_dbapi):
+        PyMSSQLInstrumentor().instrument(capture_parameters=True)
+
+        self.assertIs(
+            mock_dbapi.wrap_connect.call_args.kwargs["capture_parameters"],
+            True,
+        )
+
     @patch("pymssql.connect", new=mock_connect)
     # pylint: disable=unused-argument
     def test_instrumentor_server_param(self):
@@ -175,6 +195,59 @@ def test_instrument_connection(self):
         spans_list = self.memory_exporter.get_finished_spans()
         self.assertEqual(len(spans_list), 1)
 
+    @patch("pymssql.connect", new=mock_connect)
+    def test_instrument_connection_capture_parameters(self):
+        cnx = pymssql.connect(database="test")  # pylint: disable=no-member
+        cnx = PyMSSQLInstrumentor().instrument_connection(
+            cnx, capture_parameters=True
+        )
+        cursor = cnx.cursor()
+        cursor.execute("SELECT * FROM test WHERE id = %s", (42,))
+
+        spans_list = self.memory_exporter.get_finished_spans()
+        self.assertEqual(
+            spans_list[0].attributes["db.statement.parameters"], "(42,)"
+        )
+
+    @patch("opentelemetry.instrumentation.pymssql.dbapi")
+    def test_instrument_connection_forwards_capture_parameters(
+        self, mock_dbapi
+    ):
+        cnx = Mock()
+
+        PyMSSQLInstrumentor().instrument_connection(
+            cnx, capture_parameters=True
+        )
+
+        self.assertIs(
+            mock_dbapi.instrument_connection.call_args.kwargs[
+                "capture_parameters"
+            ],
+            True,
+        )
+
+    @patch("pymssql.connect", new=mock_connect)
+    def test_capture_parameters_deactivated_by_default(self):
+        PyMSSQLInstrumentor().instrument()
+        cnx = pymssql.connect(database="test")  # pylint: disable=no-member
+        cursor = cnx.cursor()
+        cursor.execute("SELECT * FROM test WHERE id = %s", (42,))
+
+        spans_list = self.memory_exporter.get_finished_spans()
+        self.assertNotIn("db.statement.parameters", spans_list[0].attributes)
+
+    @patch("pymssql.connect", new=mock_connect)
+    def test_capture_parameters_activated(self):
+        PyMSSQLInstrumentor().instrument(capture_parameters=True)
+        cnx = pymssql.connect(database="test")  # pylint: disable=no-member
+        cursor = cnx.cursor()
+        cursor.execute("SELECT * FROM test WHERE id = %s", (42,))
+
+        spans_list = self.memory_exporter.get_finished_spans()
+        self.assertEqual(
+            spans_list[0].attributes["db.statement.parameters"], "(42,)"
+        )
+
     @patch("pymssql.connect", new=mock_connect)
     # pylint: disable=unused-argument
     def test_uninstrument_connection(self):