From 39fad4fec687e6474efdecdfe69476f13b2924d1 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Mon, 19 Apr 2021 13:08:44 -0600 Subject: [PATCH 01/58] adding comment to clarify that log line occurs when DATADOG_PRIORITY_SAMPLING=false is set, not just when an older tracer version is being used --- ddtrace/internal/writer.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ddtrace/internal/writer.py b/ddtrace/internal/writer.py index 14e98f4c1ac..07fd1399fe9 100644 --- a/ddtrace/internal/writer.py +++ b/ddtrace/internal/writer.py @@ -111,6 +111,7 @@ def get_json(self): # This typically happens when using a priority-sampling enabled # library with an outdated agent. It still works, but priority sampling # will probably send too many traces, so the next step is to upgrade agent. + # This also happens when DATADOG_PRIORITY_SAMPLING=false is set log.debug("Cannot parse Datadog Agent response, please make sure your Datadog Agent is up to date") return From 9a22d052e2efe04002fa951060c0d5d71007b4a2 Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Wed, 21 Apr 2021 12:16:00 -0600 Subject: [PATCH 02/58] Update writer.py --- ddtrace/internal/writer.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/ddtrace/internal/writer.py b/ddtrace/internal/writer.py index 07fd1399fe9..e87b3fa8549 100644 --- a/ddtrace/internal/writer.py +++ b/ddtrace/internal/writer.py @@ -111,8 +111,7 @@ def get_json(self): # This typically happens when using a priority-sampling enabled # library with an outdated agent. It still works, but priority sampling # will probably send too many traces, so the next step is to upgrade agent. - # This also happens when DATADOG_PRIORITY_SAMPLING=false is set - log.debug("Cannot parse Datadog Agent response, please make sure your Datadog Agent is up to date") + log.debug("Cannot parse Datadog Agent response. This occurs because Datadog agent is out of date or DATADOG_PRIORITY_SAMPLING=false is set") return return loads(body) From aed7bfe28ac44110b701f3f04c473823c8c3d814 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Mon, 26 Apr 2021 15:05:02 -0600 Subject: [PATCH 03/58] got mariadb integration working on sample app --- ddtrace/contrib/mariadb/__init__.py | 67 +++++++++++++++++++++++++++++ ddtrace/contrib/mariadb/patch.py | 50 +++++++++++++++++++++ 2 files changed, 117 insertions(+) create mode 100644 ddtrace/contrib/mariadb/__init__.py create mode 100644 ddtrace/contrib/mariadb/patch.py diff --git a/ddtrace/contrib/mariadb/__init__.py b/ddtrace/contrib/mariadb/__init__.py new file mode 100644 index 00000000000..e5f11d3202d --- /dev/null +++ b/ddtrace/contrib/mariadb/__init__.py @@ -0,0 +1,67 @@ +""" +The mysql integration instruments the mysql library to trace MySQL queries. + + +Enabling +~~~~~~~~ + +The mysql integration is enabled automatically when using +:ref:`ddtrace-run` or :ref:`patch_all()`. + +Or use :ref:`patch()` to manually enable the integration:: + + from ddtrace import patch + patch(mysql=True) + + +Global Configuration +~~~~~~~~~~~~~~~~~~~~ + +.. py:data:: ddtrace.config.mysql["service"] + + The service name reported by default for mysql spans. + + This option can also be set with the ``DD_MYSQL_SERVICE`` environment + variable. + + Default: ``"mysql"`` + + +Instance Configuration +~~~~~~~~~~~~~~~~~~~~~~ + +To configure the mysql integration on an per-connection basis use the +``Pin`` API:: + + from ddtrace import Pin + # Make sure to import mysql.connector and not the 'connect' function, + # otherwise you won't have access to the patched version + import mysql.connector + + # This will report a span with the default settings + conn = mysql.connector.connect(user="alice", password="b0b", host="localhost", port=3306, database="test") + + # Use a pin to override the service name for this connection. + Pin.override(conn, service='mysql-users') + + cursor = conn.cursor() + cursor.execute("SELECT 6*7 AS the_answer;") + + +Only the default full-Python integration works. The binary C connector, +provided by _mysql_connector, is not supported. + +Help on mysql.connector can be found on: +https://dev.mysql.com/doc/connector-python/en/ +""" +from ...utils.importlib import require_modules + + +# check `mysql-connector` availability +required_modules = ["mariadb"] + +with require_modules(required_modules) as missing_modules: + if not missing_modules: + from .patch import patch + + __all__ = ["patch"] diff --git a/ddtrace/contrib/mariadb/patch.py b/ddtrace/contrib/mariadb/patch.py new file mode 100644 index 00000000000..015c76c3f4f --- /dev/null +++ b/ddtrace/contrib/mariadb/patch.py @@ -0,0 +1,50 @@ +import mariadb +from ddtrace import Pin +from ddtrace import config +from ddtrace.contrib.dbapi import TracedConnection +from ddtrace.vendor import wrapt + +from ...ext import db +from ...ext import net + + +config._add( + "mariadb", + dict( + _default_service="mariadb", + ), +) + +CONN_ATTR_BY_TAG = { + net.TARGET_HOST: "server_host", + net.TARGET_PORT: "server_port", + db.USER: "user", + db.NAME: "database", +} + + +def patch(): + wrapt.wrap_function_wrapper("mariadb", "connect", _connect) + + +def unpatch(): + if isinstance(mariadb.connect, wrapt.ObjectProxy): + mariadb.connect = mariadb.connect.__wrapped__ + if hasattr(mariadb, "Connect"): + mariadb.Connect = mariadb.connect + + +def _connect(func, instance, args, kwargs): + conn = func(*args, **kwargs) + return patch_conn(conn) + + +def patch_conn(conn): + + tags = {t: getattr(conn, a) for t, a in CONN_ATTR_BY_TAG.items() if getattr(conn, a, "") != ""} + pin = Pin(app="mariadb", tags=tags) + + # grab the metadata from the conn + wrapped = TracedConnection(conn, pin=pin, cfg=config.mariadb) + pin.onto(wrapped) + return wrapped From 2d74914ec5dea840551c5be3caa77118bdaff76d Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Mon, 3 May 2021 16:40:30 -0600 Subject: [PATCH 04/58] testing for mariadb integration setup --- ddtrace/__init__.py | 1 + ddtrace/monkey.py | 1 + docker-compose.yml | 13 + riotfile.py | 18 + tests/contrib/config.py | 8 + tests/contrib/mariadb/__init__.py | 0 .../mariadb/test_backwards_compatibility.py | 14 + tests/contrib/mariadb/test_mariadb.py | 471 ++++++++++++++++++ tests/contrib/mariadb/test_mariadbpytest.py | 49 ++ 9 files changed, 575 insertions(+) create mode 100644 tests/contrib/mariadb/__init__.py create mode 100644 tests/contrib/mariadb/test_backwards_compatibility.py create mode 100644 tests/contrib/mariadb/test_mariadb.py create mode 100644 tests/contrib/mariadb/test_mariadbpytest.py diff --git a/ddtrace/__init__.py b/ddtrace/__init__.py index f0238cdb39d..fbca7afaa64 100644 --- a/ddtrace/__init__.py +++ b/ddtrace/__init__.py @@ -8,6 +8,7 @@ from .tracer import Tracer # noqa: E402 from .utils.deprecation import deprecated # noqa: E402 +print("Hello tracing") try: __version__ = pkg_resources.get_distribution(__name__).version diff --git a/ddtrace/monkey.py b/ddtrace/monkey.py index ff5ba808feb..75d2050b208 100644 --- a/ddtrace/monkey.py +++ b/ddtrace/monkey.py @@ -42,6 +42,7 @@ "mysql": True, "mysqldb": True, "pymysql": True, + "mariadb": True, "psycopg": True, "pylibmc": True, "pymemcache": True, diff --git a/docker-compose.yml b/docker-compose.yml index 55f88f06148..4d6fdeee426 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -25,6 +25,19 @@ services: - POSTGRES_DB=postgres ports: - "127.0.0.1:5432:5432" + version: '3.1' + + mariadb: + image: mariadb + restart: always + environment: + - MYSQL_ROOT_PASSWORD=example + - MYSQL_DATABASE=test + - MYSQL_USER=test + - MYSQL_PASSWORD=test + ports: + - "127.0.0.1:3306:3306" + mysql: image: mysql:5.7 environment: diff --git a/riotfile.py b/riotfile.py index 9293993856b..0f7885fd2c5 100644 --- a/riotfile.py +++ b/riotfile.py @@ -519,6 +519,24 @@ def select_pys(min_version=MIN_PYTHON_VERSION, max_version=MAX_PYTHON_VERSION): pys=select_pys(), pkgs={"mako": ["<1.0.0", "~=1.0.0", "~=1.1.0", latest]}, ), + Venv( + name="mariadb", + command="pytest {cmdargs} tests/contrib/mariadb", + venvs=[ + Venv( + pys=select_pys(max_version="1.0.6"), + pkgs={ + "pymongo": [ + ">=1.0.0,<1.0.1", + ">=1.0.1,<1.0.2", + ">=1.0.2,<1.0.3", + ">=1.0.3,<1.0.4", + ">=1.0.4,<1.0.5", + ">=1.0.5,<1.0.6", + latest, + ], + }, + ), Venv( name="psycopg", command="pytest {cmdargs} tests/contrib/psycopg", diff --git a/tests/contrib/config.py b/tests/contrib/config.py index c69b9aa83bf..c9f11d88eeb 100644 --- a/tests/contrib/config.py +++ b/tests/contrib/config.py @@ -40,6 +40,14 @@ 'database': os.getenv('TEST_MYSQL_DATABASE', 'test'), } +MARIADB_CONFIG = { + 'host': '127.0.0.1', + 'port': int(os.getenv('TEST_MYSQL_PORT', 3306)), + 'user': os.getenv('TEST_MYSQL_USER', 'test'), + 'password': os.getenv('TEST_MYSQL_PASSWORD', 'test'), + 'database': os.getenv('TEST_MYSQL_DATABASE', 'test'), +} + REDIS_CONFIG = { 'port': int(os.getenv('TEST_REDIS_PORT', 6379)), } diff --git a/tests/contrib/mariadb/__init__.py b/tests/contrib/mariadb/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/tests/contrib/mariadb/test_backwards_compatibility.py b/tests/contrib/mariadb/test_backwards_compatibility.py new file mode 100644 index 00000000000..62e405d3860 --- /dev/null +++ b/tests/contrib/mariadb/test_backwards_compatibility.py @@ -0,0 +1,14 @@ +##For Maria DB I don't think this is necesarry, unless Mariadb has an older version that's different. I tested on Mariadb version +## 1.0.6. It looks like https://github.com/mariadb-corporation/mariadb-connector-python/releases?after=v0.9.57 was the first beta release and it doesn't seem to be out of beta yet. +# from ddtrace.contrib.mysql import get_traced_mysql_connection +# from tests.contrib import config +# from tests.utils import DummyTracer + + +# def test_pre_v4(): +# tracer = DummyTracer() +# MySQL = get_traced_mysql_connection(tracer, service="my-mysql-server") +# conn = MySQL(**config.MYSQL_CONFIG) +# cursor = conn.cursor() +# cursor.execute("SELECT 1") +# assert cursor.fetchone()[0] == 1 diff --git a/tests/contrib/mariadb/test_mariadb.py b/tests/contrib/mariadb/test_mariadb.py new file mode 100644 index 00000000000..ae81d8f98c6 --- /dev/null +++ b/tests/contrib/mariadb/test_mariadb.py @@ -0,0 +1,471 @@ +import mysql + +from ddtrace import Pin +from ddtrace.constants import ANALYTICS_SAMPLE_RATE_KEY +from ddtrace.contrib.mariadb.patch import patch +from ddtrace.contrib.mariadb.patch import unpatch +from tests.contrib.config import MYSQL_CONFIG +from tests.opentracer.utils import init_tracer +from tests.utils import TracerTestCase +from tests.utils import assert_dict_issuperset +from tests.utils import assert_is_measured + + +class MySQLCore(object): + """Base test case for MySQL drivers""" + + conn = None + + def tearDown(self): + super(MySQLCore, self).tearDown() + + # Reuse the connection across tests + if self.conn: + try: + self.conn.ping() + except mysql.InterfaceError: + pass + else: + self.conn.close() + unpatch() + + def _get_conn_tracer(self): + # implement me + pass + + def test_simple_query(self): + conn, tracer = self._get_conn_tracer() + cursor = conn.cursor() + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + spans = tracer.pop() + assert len(spans) == 1 + + span = spans[0] + assert_is_measured(span) + assert span.service == "mysql" + assert span.name == "mysql.query" + assert span.span_type == "sql" + assert span.error == 0 + assert span.get_metric("out.port") == 3306 + assert_dict_issuperset( + span.meta, + { + "out.host": u"127.0.0.1", + "db.name": u"test", + "db.user": u"test", + }, + ) + + def test_simple_query_fetchll(self): + with self.override_config("dbapi2", dict(trace_fetch_methods=True)): + conn, tracer = self._get_conn_tracer() + cursor = conn.cursor() + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + spans = tracer.pop() + assert len(spans) == 2 + + span = spans[0] + assert_is_measured(span) + assert span.service == "mysql" + assert span.name == "mysql.query" + assert span.span_type == "sql" + assert span.error == 0 + assert span.get_metric("out.port") == 3306 + assert_dict_issuperset( + span.meta, + { + "out.host": u"127.0.0.1", + "db.name": u"test", + "db.user": u"test", + }, + ) + + assert spans[1].name == "mysql.query.fetchall" + + def test_query_with_several_rows(self): + conn, tracer = self._get_conn_tracer() + cursor = conn.cursor() + query = "SELECT n FROM (SELECT 42 n UNION SELECT 421 UNION SELECT 4210) m" + cursor.execute(query) + rows = cursor.fetchall() + assert len(rows) == 3 + spans = tracer.pop() + assert len(spans) == 1 + span = spans[0] + assert span.get_tag("sql.query") is None + + def test_query_with_several_rows_fetchall(self): + with self.override_config("dbapi2", dict(trace_fetch_methods=True)): + conn, tracer = self._get_conn_tracer() + cursor = conn.cursor() + query = "SELECT n FROM (SELECT 42 n UNION SELECT 421 UNION SELECT 4210) m" + cursor.execute(query) + rows = cursor.fetchall() + assert len(rows) == 3 + spans = tracer.pop() + assert len(spans) == 2 + span = spans[0] + assert span.get_tag("sql.query") is None + assert spans[1].name == "mysql.query.fetchall" + + def test_query_many(self): + # tests that the executemany method is correctly wrapped. + conn, tracer = self._get_conn_tracer() + tracer.enabled = False + cursor = conn.cursor() + + cursor.execute( + """ + create table if not exists dummy ( + dummy_key VARCHAR(32) PRIMARY KEY, + dummy_value TEXT NOT NULL)""" + ) + tracer.enabled = True + + stmt = "INSERT INTO dummy (dummy_key, dummy_value) VALUES (%s, %s)" + data = [ + ("foo", "this is foo"), + ("bar", "this is bar"), + ] + cursor.executemany(stmt, data) + query = "SELECT dummy_key, dummy_value FROM dummy ORDER BY dummy_key" + cursor.execute(query) + rows = cursor.fetchall() + assert len(rows) == 2 + assert rows[0][0] == "bar" + assert rows[0][1] == "this is bar" + assert rows[1][0] == "foo" + assert rows[1][1] == "this is foo" + + spans = tracer.pop() + assert len(spans) == 2 + span = spans[-1] + assert span.get_tag("sql.query") is None + cursor.execute("drop table if exists dummy") + + def test_query_many_fetchall(self): + with self.override_config("dbapi2", dict(trace_fetch_methods=True)): + # tests that the executemany method is correctly wrapped. + conn, tracer = self._get_conn_tracer() + tracer.enabled = False + cursor = conn.cursor() + + cursor.execute( + """ + create table if not exists dummy ( + dummy_key VARCHAR(32) PRIMARY KEY, + dummy_value TEXT NOT NULL)""" + ) + tracer.enabled = True + + stmt = "INSERT INTO dummy (dummy_key, dummy_value) VALUES (%s, %s)" + data = [ + ("foo", "this is foo"), + ("bar", "this is bar"), + ] + cursor.executemany(stmt, data) + query = "SELECT dummy_key, dummy_value FROM dummy ORDER BY dummy_key" + cursor.execute(query) + rows = cursor.fetchall() + assert len(rows) == 2 + assert rows[0][0] == "bar" + assert rows[0][1] == "this is bar" + assert rows[1][0] == "foo" + assert rows[1][1] == "this is foo" + + spans = tracer.pop() + assert len(spans) == 3 + span = spans[-1] + assert span.get_tag("sql.query") is None + cursor.execute("drop table if exists dummy") + + assert spans[2].name == "mysql.query.fetchall" + + def test_query_proc(self): + conn, tracer = self._get_conn_tracer() + + # create a procedure + tracer.enabled = False + cursor = conn.cursor() + cursor.execute("DROP PROCEDURE IF EXISTS sp_sum") + cursor.execute( + """ + CREATE PROCEDURE sp_sum (IN p1 INTEGER, IN p2 INTEGER, OUT p3 INTEGER) + BEGIN + SET p3 := p1 + p2; + END;""" + ) + + tracer.enabled = True + proc = "sp_sum" + data = (40, 2, None) + output = cursor.callproc(proc, data) + assert len(output) == 3 + assert output[2] == 42 + + spans = tracer.pop() + assert spans, spans + + # number of spans depends on MySQL implementation details, + # typically, internal calls to execute, but at least we + # can expect the last closed span to be our proc. + span = spans[len(spans) - 1] + assert_is_measured(span) + assert span.service == "mysql" + assert span.name == "mysql.query" + assert span.span_type == "sql" + assert span.error == 0 + assert span.get_metric("out.port") == 3306 + assert_dict_issuperset( + span.meta, + { + "out.host": u"127.0.0.1", + "db.name": u"test", + "db.user": u"test", + }, + ) + assert span.get_tag("sql.query") is None + + def test_simple_query_ot(self): + """OpenTracing version of test_simple_query.""" + conn, tracer = self._get_conn_tracer() + + ot_tracer = init_tracer("mysql_svc", tracer) + + with ot_tracer.start_active_span("mysql_op"): + cursor = conn.cursor() + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + + spans = tracer.pop() + assert len(spans) == 2 + + ot_span, dd_span = spans + + # confirm parenting + assert ot_span.parent_id is None + assert dd_span.parent_id == ot_span.span_id + + assert ot_span.service == "mysql_svc" + assert ot_span.name == "mysql_op" + + assert_is_measured(dd_span) + assert dd_span.service == "mysql" + assert dd_span.name == "mysql.query" + assert dd_span.span_type == "sql" + assert dd_span.error == 0 + assert dd_span.get_metric("out.port") == 3306 + assert_dict_issuperset( + dd_span.meta, + { + "out.host": u"127.0.0.1", + "db.name": u"test", + "db.user": u"test", + }, + ) + + def test_simple_query_ot_fetchall(self): + """OpenTracing version of test_simple_query.""" + with self.override_config("dbapi2", dict(trace_fetch_methods=True)): + conn, tracer = self._get_conn_tracer() + + ot_tracer = init_tracer("mysql_svc", tracer) + + with ot_tracer.start_active_span("mysql_op"): + cursor = conn.cursor() + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + + spans = tracer.pop() + assert len(spans) == 3 + + ot_span, dd_span, fetch_span = spans + + # confirm parenting + assert ot_span.parent_id is None + assert dd_span.parent_id == ot_span.span_id + + assert ot_span.service == "mysql_svc" + assert ot_span.name == "mysql_op" + + assert_is_measured(dd_span) + assert dd_span.service == "mysql" + assert dd_span.name == "mysql.query" + assert dd_span.span_type == "sql" + assert dd_span.error == 0 + assert dd_span.get_metric("out.port") == 3306 + assert_dict_issuperset( + dd_span.meta, + { + "out.host": u"127.0.0.1", + "db.name": u"test", + "db.user": u"test", + }, + ) + + assert fetch_span.name == "mysql.query.fetchall" + + def test_commit(self): + conn, tracer = self._get_conn_tracer() + conn.commit() + spans = tracer.pop() + assert len(spans) == 1 + span = spans[0] + assert span.service == "mysql" + assert span.name == "mysql.connection.commit" + + def test_rollback(self): + conn, tracer = self._get_conn_tracer() + conn.rollback() + spans = tracer.pop() + assert len(spans) == 1 + span = spans[0] + assert span.service == "mysql" + assert span.name == "mysql.connection.rollback" + + def test_analytics_default(self): + conn, tracer = self._get_conn_tracer() + cursor = conn.cursor() + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + spans = tracer.pop() + + self.assertEqual(len(spans), 1) + span = spans[0] + self.assertIsNone(span.get_metric(ANALYTICS_SAMPLE_RATE_KEY)) + + def test_analytics_with_rate(self): + with self.override_config("dbapi2", dict(analytics_enabled=True, analytics_sample_rate=0.5)): + conn, tracer = self._get_conn_tracer() + cursor = conn.cursor() + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + spans = tracer.pop() + + self.assertEqual(len(spans), 1) + span = spans[0] + self.assertEqual(span.get_metric(ANALYTICS_SAMPLE_RATE_KEY), 0.5) + + def test_analytics_without_rate(self): + with self.override_config("dbapi2", dict(analytics_enabled=True)): + conn, tracer = self._get_conn_tracer() + cursor = conn.cursor() + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + spans = tracer.pop() + + self.assertEqual(len(spans), 1) + span = spans[0] + self.assertEqual(span.get_metric(ANALYTICS_SAMPLE_RATE_KEY), 1.0) + + @TracerTestCase.run_in_subprocess(env_overrides=dict(DD_SERVICE="mysvc")) + def test_user_specified_service(self): + """ + When a user specifies a service for the app + The mysql integration should not use it. + """ + # Ensure that the service name was configured + from ddtrace import config + + assert config.service == "mysvc" + + conn, tracer = self._get_conn_tracer() + cursor = conn.cursor() + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + spans = tracer.pop() + + assert spans[0].service != "mysvc" + + +class TestMysqlPatch(MySQLCore, TracerTestCase): + def setUp(self): + super(TestMysqlPatch, self).setUp() + patch() + + def tearDown(self): + super(TestMysqlPatch, self).tearDown() + unpatch() + + def _get_conn_tracer(self): + if not self.conn: + self.conn = mysql.connector.connect(**MYSQL_CONFIG) + assert self.conn.is_connected() + # Ensure that the default pin is there, with its default value + pin = Pin.get_from(self.conn) + assert pin + # assert pin.service == 'mysql' + # Customize the service + # we have to apply it on the existing one since new one won't inherit `app` + pin.clone(tracer=self.tracer).onto(self.conn) + + return self.conn, self.tracer + + def test_patch_unpatch(self): + unpatch() + # assert we start unpatched + conn = mysql.connector.connect(**MYSQL_CONFIG) + assert not Pin.get_from(conn) + conn.close() + + patch() + try: + conn = mysql.connector.connect(**MYSQL_CONFIG) + pin = Pin.get_from(conn) + assert pin + pin.clone(service="pin-svc", tracer=self.tracer).onto(conn) + assert conn.is_connected() + + cursor = conn.cursor() + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + spans = self.pop_spans() + assert len(spans) == 1 + + span = spans[0] + assert span.service == "pin-svc" + assert span.name == "mysql.query" + assert span.span_type == "sql" + assert span.error == 0 + assert span.get_metric("out.port") == 3306 + assert_dict_issuperset( + span.meta, + { + "out.host": u"127.0.0.1", + "db.name": u"test", + "db.user": u"test", + }, + ) + assert span.get_tag("sql.query") is None + + finally: + unpatch() + + # assert we finish unpatched + conn = mysql.connector.connect(**MYSQL_CONFIG) + assert not Pin.get_from(conn) + conn.close() + + patch() + + @TracerTestCase.run_in_subprocess(env_overrides=dict(DD_MYSQL_SERVICE="mysvc")) + def test_user_specified_service_integration(self): + conn, tracer = self._get_conn_tracer() + cursor = conn.cursor() + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + spans = tracer.pop() + + assert spans[0].service == "mysvc" diff --git a/tests/contrib/mariadb/test_mariadbpytest.py b/tests/contrib/mariadb/test_mariadbpytest.py new file mode 100644 index 00000000000..7c9371034dd --- /dev/null +++ b/tests/contrib/mariadb/test_mariadbpytest.py @@ -0,0 +1,49 @@ +import pytest +import mariadb +from tests.utils import DummyTracer +from tests.utils import assert_is_measured + + + + +@pytest.fixture +def tracer(): + tracer = DummyTracer() + + # Yield to our test + yield tracer + tracer.pop() + + +@pytest.fixture +def connection(tracer): + connection = mariadb.connect( + user="user", + password="user", + host="127.0.0.1", + port=3306, + database="employees" + ) + Pin.override(connection, tracer=tracer) +#need to figure out where the code to make the db goes, previously it went in an init +#db file but now maybe i should just use the connection to create a database here? +# CREATE DATABASE IF NOT EXISTS `test`; +# GRANT ALL ON `test`.* TO 'user'@'%'; + yield connection + connection.close() + + +def test_simple_query(connection, tracer): + cursor = connection.cursor() + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + spans = tracer.pop() + assert len(spans) == 1 + span = spans[0] + assert_is_measured(span) + assert span.service == "mariadb" + assert span.name == "mariadb.query" + assert span.span_type == "sql" + assert span.error == 0 + assert span.get_metric("out.port") == 3306 From a501d4240724b68dbc238e6225ff676d402eb2eb Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Mon, 10 May 2021 14:41:07 -0600 Subject: [PATCH 05/58] fixed riot.py file so mariadb tests run --- riotfile.py | 171 +++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 150 insertions(+), 21 deletions(-) diff --git a/riotfile.py b/riotfile.py index 0f7885fd2c5..a75751254d1 100644 --- a/riotfile.py +++ b/riotfile.py @@ -75,15 +75,15 @@ def select_pys(min_version=MIN_PYTHON_VERSION, max_version=MAX_PYTHON_VERSION): pkgs={ "mock": latest, "pytest": latest, - "coverage": latest, - "pytest-cov": latest, + # "coverage": latest, + # "pytest-cov": latest, "opentracing": latest, "hypothesis": latest, }, venvs=[ Venv( pys=["3"], - pkgs={"black": "==20.8b1"}, + pkgs={"black": "==21.4b2"}, venvs=[ Venv( name="fmt", @@ -141,7 +141,7 @@ def select_pys(min_version=MIN_PYTHON_VERSION, max_version=MAX_PYTHON_VERSION): name="benchmarks", pys=select_pys(), pkgs={"pytest-benchmark": latest, "msgpack": latest}, - command="pytest --no-cov {cmdargs} tests/benchmarks", + command="pytest {cmdargs} tests/benchmarks", ), Venv( name="tracer", @@ -152,13 +152,19 @@ def select_pys(min_version=MIN_PYTHON_VERSION, max_version=MAX_PYTHON_VERSION): pkgs={ "msgpack": latest, "attrs": ["==19.2.0", latest], + "packaging": ["==17.1", latest], }, ) ], ), + Venv( + name="runtime", + command="pytest {cmdargs} tests/runtime/", + venvs=[Venv(pys=select_pys(), pkgs={"msgpack": latest})], + ), Venv( name="ddtracerun", - command="pytest {cmdargs} --no-cov tests/commands/test_runner.py", + command="pytest {cmdargs} tests/commands/test_runner.py", pys=select_pys(), pkgs={ "redis": latest, @@ -175,6 +181,85 @@ def select_pys(min_version=MIN_PYTHON_VERSION, max_version=MAX_PYTHON_VERSION): command="pytest {cmdargs} tests/contrib/logging", pys=select_pys(), ), + Venv( + name="celery", + command="pytest {cmdargs} tests/contrib/celery", + venvs=[ + # Non-4.x celery should be able to use the older redis lib, since it locks to an older kombu + Venv( + pys=select_pys(max_version="3.6"), + pkgs={ + "celery": "~=3.0", # most recent 3.x.x release + "redis": "~=2.10.6", + }, + ), + # 4.x celery bumps kombu to 4.4+, which requires redis 3.2 or later, this tests against + # older redis with an older kombu, and newer kombu/newer redis. + # https://github.com/celery/kombu/blob/3e60e6503a77b9b1a987cf7954659929abac9bac/Changelog#L35 + Venv( + pys=select_pys(max_version="3.6"), + pkgs={ + "celery": [ + "~=4.0.2", + "~=4.1.1", + ], + "redis": "~=2.10.6", + "kombu": "~=4.3.0", + "pytest": "~=3.10", + }, + ), + Venv( + pys=select_pys(max_version="3.6"), + pkgs={ + "celery": [ + "~=4.0.2", + "~=4.1.1", + ], + "redis": "~=3.5", + "kombu": "~=4.4.0", + }, + ), + # Celery 4.2 is now limited to Kombu 4.3 + # https://github.com/celery/celery/commit/1571d414461f01ae55be63a03e2adaa94dbcb15d + Venv( + pys=select_pys(max_version="3.6"), + pkgs={ + "celery": "~=4.2.2", + "redis": "~=2.10.6", + "kombu": "~=4.3.0", + }, + ), + # Celery 4.3 wants Kombu >= 4.4 and Redis >= 3.2 + Venv( + pys=select_pys(), + pkgs={ + "celery": [ + "~=4.3.1", + "~=4.4.7", + "~=4.4", # most recent 4.x + ], + "redis": "~=3.5", + "kombu": "~=4.4", + }, + ), + # Celery 5.x wants Python 3.6+ + Venv( + pys=select_pys(min_version="3.6"), + env={ + # https://docs.celeryproject.org/en/v5.0.5/userguide/testing.html#enabling + "PYTEST_PLUGINS": "celery.contrib.pytest", + }, + pkgs={ + "celery": [ + "~=5.0.5", + "~=5.0", # most recent 5.x + latest, + ], + "redis": "~=3.5", + }, + ), + ], + ), Venv( name="cherrypy", command="pytest {cmdargs} tests/contrib/cherrypy", @@ -520,23 +605,19 @@ def select_pys(min_version=MIN_PYTHON_VERSION, max_version=MAX_PYTHON_VERSION): pkgs={"mako": ["<1.0.0", "~=1.0.0", "~=1.1.0", latest]}, ), Venv( - name="mariadb", - command="pytest {cmdargs} tests/contrib/mariadb", + name="mysql", + command="pytest {cmdargs} tests/contrib/mysql", venvs=[ Venv( - pys=select_pys(max_version="1.0.6"), - pkgs={ - "pymongo": [ - ">=1.0.0,<1.0.1", - ">=1.0.1,<1.0.2", - ">=1.0.2,<1.0.3", - ">=1.0.3,<1.0.4", - ">=1.0.4,<1.0.5", - ">=1.0.5,<1.0.6", - latest, - ], - }, + pys="2.7", + pkgs={"mysql-connector-python": ["==8.0.5", "<8.0.24"]}, ), + Venv( + pys=select_pys(min_version="3"), + pkgs={"mysql-connector-python": ["==8.0.5", ">=8.0", latest]}, + ), + ], + ), Venv( name="psycopg", command="pytest {cmdargs} tests/contrib/psycopg", @@ -555,6 +636,26 @@ def select_pys(min_version=MIN_PYTHON_VERSION, max_version=MAX_PYTHON_VERSION): ), ], ), + Venv( + name="pymemcache", + pys=select_pys(), + pkgs={ + "pymemcache": [ + "~=1.4", # Most recent 1.x release + "~=2.0", # Most recent 2.x release + "~=3.0.1", + "~=3.1.1", + "~=3.2.0", + "~=3.3.0", + "~=3.4.2", + latest, + ] + }, + venvs=[ + Venv(command="pytest {cmdargs} --ignore=tests/contrib/pymemcache/autopatch tests/contrib/pymemcache"), + Venv(command="python tests/ddtrace_run.py pytest {cmdargs} tests/contrib/pymemcache/autopatch/"), + ], + ), Venv( name="pynamodb", command="pytest {cmdargs} tests/contrib/pynamodb", @@ -597,7 +698,15 @@ def select_pys(min_version=MIN_PYTHON_VERSION, max_version=MAX_PYTHON_VERSION): command="pytest {cmdargs} tests/contrib/sqlalchemy", venvs=[ Venv( - pys=select_pys(), + pys=select_pys(max_version="3"), + pkgs={ + "sqlalchemy": ["~=1.0.0", "~=1.1.0", "~=1.2.0", "~=1.3.0", latest], + "psycopg2": ["~=2.8.0"], + "mysql-connector-python": ["<8.0.24"], + }, + ), + Venv( + pys=select_pys(min_version="3"), pkgs={ "sqlalchemy": ["~=1.0.0", "~=1.1.0", "~=1.2.0", "~=1.3.0", latest], "psycopg2": ["~=2.8.0"], @@ -684,6 +793,26 @@ def select_pys(min_version=MIN_PYTHON_VERSION, max_version=MAX_PYTHON_VERSION): pys=select_pys(min_version="3.6"), command="pytest {cmdargs} tests/contrib/asgi", ), + Venv( + name="mariadb", + command="pytest {cmdargs} tests/contrib/mariadb", + venvs=[ + Venv( + pys=select_pys(max_version="1.0.6"), + pkgs={ + "pymongo": [ + ">=1.0.0,<1.0.1", + ">=1.0.1,<1.0.2", + ">=1.0.2,<1.0.3", + ">=1.0.3,<1.0.4", + ">=1.0.4,<1.0.5", + ">=1.0.5,<1.0.6", + latest, + ], + }, + ), + ], + ), Venv( name="fastapi", command="pytest {cmdargs} tests/contrib/fastapi", @@ -749,4 +878,4 @@ def select_pys(min_version=MIN_PYTHON_VERSION, max_version=MAX_PYTHON_VERSION): command="pytest {cmdargs} tests/contrib/urllib3", ), ], -) +) \ No newline at end of file From 3f23a6413b33193bb6063444c3bae1398a203ee3 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Mon, 10 May 2021 16:34:09 -0600 Subject: [PATCH 06/58] beginning conversion of mysql tests to mariadb tests with new formats --- docker-compose.yml | 1 - tests/contrib/mariadb/test_mariadbpytest.py | 436 +++++++++++++++++++- 2 files changed, 434 insertions(+), 3 deletions(-) diff --git a/docker-compose.yml b/docker-compose.yml index 4d6fdeee426..22d52ec39a4 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -29,7 +29,6 @@ services: mariadb: image: mariadb - restart: always environment: - MYSQL_ROOT_PASSWORD=example - MYSQL_DATABASE=test diff --git a/tests/contrib/mariadb/test_mariadbpytest.py b/tests/contrib/mariadb/test_mariadbpytest.py index 7c9371034dd..d5c7d6e8a70 100644 --- a/tests/contrib/mariadb/test_mariadbpytest.py +++ b/tests/contrib/mariadb/test_mariadbpytest.py @@ -2,14 +2,13 @@ import mariadb from tests.utils import DummyTracer from tests.utils import assert_is_measured - +from tests.utils import assert_dict_issuperset @pytest.fixture def tracer(): tracer = DummyTracer() - # Yield to our test yield tracer tracer.pop() @@ -47,3 +46,436 @@ def test_simple_query(connection, tracer): assert span.span_type == "sql" assert span.error == 0 assert span.get_metric("out.port") == 3306 + assert_dict_issuperset( + span.meta, + { + "out.host": u"127.0.0.1", + "db.name": u"test", + "db.user": u"test", + }, + ) + +def test_simple_query_fetchll(connection, tracer): + ##Overide the tracer rather than the self object (how it's done in test_mysql.py) + tracer.override_config("dbapi2", dict(trace_fetch_methods=True)) + cursor = connection.cursor() + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + spans = tracer.pop() + assert len(spans) == 2 + + span = spans[0] + assert_is_measured(span) + assert span.service == "mariadb" + assert span.name == "mariadb.query" + assert span.span_type == "sql" + assert span.error == 0 + assert span.get_metric("out.port") == 3306 + assert_dict_issuperset( + span.meta, + { + "out.host": u"127.0.0.1", + "db.name": u"test", + "db.user": u"test", + }, + ) + + assert spans[1].name == "mariadb.query.fetchall" + +def test_simple_query_fetchll(connection, tracer): + with self.override_config("dbapi2", dict(trace_fetch_methods=True)): + cursor = connection.cursor + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + spans = tracer.pop() + assert len(spans) == 2 + + span = spans[0] + assert_is_measured(span) + assert span.service == "mariadb" + assert span.name == "mariadb.query" + assert span.span_type == "sql" + assert span.error == 0 + assert span.get_metric("out.port") == 3306 + assert_dict_issuperset( + span.meta, + { + "out.host": u"127.0.0.1", + "db.name": u"test", + "db.user": u"test", + }, + ) + + assert spans[1].name == "mariadb.query.fetchall" + +def test_query_with_several_rows(connection, tracer): + cursor = connection.cursor() + query = "SELECT n FROM (SELECT 42 n UNION SELECT 421 UNION SELECT 4210) m" + cursor.execute(query) + rows = cursor.fetchall() + assert len(rows) == 3 + spans = tracer.pop() + assert len(spans) == 1 + span = spans[0] + assert span.get_tag("sql.query") is None + +def test_query_with_several_rows_fetchall(connection, tracer): + with self.override_config("dbapi2", dict(trace_fetch_methods=True)): + cursor = connection.cursor + query = "SELECT n FROM (SELECT 42 n UNION SELECT 421 UNION SELECT 4210) m" + cursor.execute(query) + rows = cursor.fetchall() + assert len(rows) == 3 + spans = tracer.pop() + assert len(spans) == 2 + span = spans[0] + assert span.get_tag("sql.query") is None + assert spans[1].name == "mariadb.query.fetchall" + +def test_query_many(connection, tracer): + # tests that the executemany method is correctly wrapped. + tracer.enabled = False + cursor = connection.cursor + + cursor.execute( + """ + create table if not exists dummy ( + dummy_key VARCHAR(32) PRIMARY KEY, + dummy_value TEXT NOT NULL)""" + ) + tracer.enabled = True + + stmt = "INSERT INTO dummy (dummy_key, dummy_value) VALUES (%s, %s)" + data = [ + ("foo", "this is foo"), + ("bar", "this is bar"), + ] + cursor.executemany(stmt, data) + query = "SELECT dummy_key, dummy_value FROM dummy ORDER BY dummy_key" + cursor.execute(query) + rows = cursor.fetchall() + assert len(rows) == 2 + assert rows[0][0] == "bar" + assert rows[0][1] == "this is bar" + assert rows[1][0] == "foo" + assert rows[1][1] == "this is foo" + + spans = tracer.pop() + assert len(spans) == 2 + span = spans[-1] + assert span.get_tag("sql.query") is None + cursor.execute("drop table if exists dummy") + +def test_query_many_fetchall(connection, tracer): + with self.override_config("dbapi2", dict(trace_fetch_methods=True)): + # tests that the executemany method is correctly wrapped. + tracer.enabled = False + cursor = connection.cursor + + cursor.execute( + """ + create table if not exists dummy ( + dummy_key VARCHAR(32) PRIMARY KEY, + dummy_value TEXT NOT NULL)""" + ) + tracer.enabled = True + + stmt = "INSERT INTO dummy (dummy_key, dummy_value) VALUES (%s, %s)" + data = [ + ("foo", "this is foo"), + ("bar", "this is bar"), + ] + cursor.executemany(stmt, data) + query = "SELECT dummy_key, dummy_value FROM dummy ORDER BY dummy_key" + cursor.execute(query) + rows = cursor.fetchall() + assert len(rows) == 2 + assert rows[0][0] == "bar" + assert rows[0][1] == "this is bar" + assert rows[1][0] == "foo" + assert rows[1][1] == "this is foo" + + spans = tracer.pop() + assert len(spans) == 3 + span = spans[-1] + assert span.get_tag("sql.query") is None + cursor.execute("drop table if exists dummy") + + assert spans[2].name == "mariadb.query.fetchall" + +def test_query_proc(connection, tracer): + + # create a procedure + tracer.enabled = False + cursor = connection.cursor + cursor.execute("DROP PROCEDURE IF EXISTS sp_sum") + cursor.execute( + """ + CREATE PROCEDURE sp_sum (IN p1 INTEGER, IN p2 INTEGER, OUT p3 INTEGER) + BEGIN + SET p3 := p1 + p2; + END;""" + ) + + tracer.enabled = True + proc = "sp_sum" + data = (40, 2, None) + output = cursor.callproc(proc, data) + assert len(output) == 3 + assert output[2] == 42 + + spans = tracer.pop() + assert spans, spans + + # number of spans depends on mariadb implementation details, + # typically, internal calls to execute, but at least we + # can expect the last closed span to be our proc. + span = spans[len(spans) - 1] + assert_is_measured(span) + assert span.service == "mariadb" + assert span.name == "mariadb.query" + assert span.span_type == "sql" + assert span.error == 0 + assert span.get_metric("out.port") == 3306 + assert_dict_issuperset( + span.meta, + { + "out.host": u"127.0.0.1", + "db.name": u"test", + "db.user": u"test", + }, + ) + assert span.get_tag("sql.query") is None + +def test_simple_query_ot(connection, tracer): + """OpenTracing version of test_simple_query.""" + + ot_tracer = init_tracer("mariadb_svc", tracer) + + with ot_tracer.start_active_span("mariadb_op"): + cursor = connection.cursor + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + + spans = tracer.pop() + assert len(spans) == 2 + + ot_span, dd_span = spans + + # confirm parenting + assert ot_span.parent_id is None + assert dd_span.parent_id == ot_span.span_id + + assert ot_span.service == "mariadb_svc" + assert ot_span.name == "mariadb_op" + + assert_is_measured(dd_span) + assert dd_span.service == "mariadb" + assert dd_span.name == "mariadb.query" + assert dd_span.span_type == "sql" + assert dd_span.error == 0 + assert dd_span.get_metric("out.port") == 3306 + assert_dict_issuperset( + dd_span.meta, + { + "out.host": u"127.0.0.1", + "db.name": u"test", + "db.user": u"test", + }, + ) + +def test_simple_query_ot_fetchall(connection, tracer): + """OpenTracing version of test_simple_query.""" + with self.override_config("dbapi2", dict(trace_fetch_methods=True)): + + ot_tracer = init_tracer("mariadb_svc", tracer) + + with ot_tracer.start_active_span("mariadb_op"): + cursor = connection.cursor + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + + spans = tracer.pop() + assert len(spans) == 3 + + ot_span, dd_span, fetch_span = spans + + # confirm parenting + assert ot_span.parent_id is None + assert dd_span.parent_id == ot_span.span_id + + assert ot_span.service == "mariadb_svc" + assert ot_span.name == "mariadb_op" + + assert_is_measured(dd_span) + assert dd_span.service == "mariadb" + assert dd_span.name == "mariadb.query" + assert dd_span.span_type == "sql" + assert dd_span.error == 0 + assert dd_span.get_metric("out.port") == 3306 + assert_dict_issuperset( + dd_span.meta, + { + "out.host": u"127.0.0.1", + "db.name": u"test", + "db.user": u"test", + }, + ) + + assert fetch_span.name == "mariadb.query.fetchall" + +def test_commit(connection, tracer): + conn.commit() + spans = tracer.pop() + assert len(spans) == 1 + span = spans[0] + assert span.service == "mariadb" + assert span.name == "mariadb.connection.commit" + +def test_rollback(connection, tracer): + conn.rollback() + spans = tracer.pop() + assert len(spans) == 1 + span = spans[0] + assert span.service == "mariadb" + assert span.name == "mariadb.connection.rollback" + +def test_analytics_default(connection, tracer): + cursor = connection.cursor + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + spans = tracer.pop() + + self.assertEqual(len(spans), 1) + span = spans[0] + self.assertIsNone(span.get_metric(ANALYTICS_SAMPLE_RATE_KEY)) + +def test_analytics_with_rate(connection, tracer): + with self.override_config("dbapi2", dict(analytics_enabled=True, analytics_sample_rate=0.5)): + cursor = connection.cursor + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + spans = tracer.pop() + + self.assertEqual(len(spans), 1) + span = spans[0] + self.assertEqual(span.get_metric(ANALYTICS_SAMPLE_RATE_KEY), 0.5) + +def test_analytics_without_rate(connection, tracer): + with self.override_config("dbapi2", dict(analytics_enabled=True)): + cursor = connection.cursor + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + spans = tracer.pop() + + self.assertEqual(len(spans), 1) + span = spans[0] + self.assertEqual(span.get_metric(ANALYTICS_SAMPLE_RATE_KEY), 1.0) + +@TracerTestCase.run_in_subprocess(env_overrides=dict(DD_SERVICE="mysvc")) +def test_user_specified_service(connection, tracer): + """ + When a user specifies a service for the app + The mariadb integration should not use it. + """ + # Ensure that the service name was configured + from ddtrace import config + + assert config.service == "mysvc" + + cursor = connection.cursor + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + spans = tracer.pop() + + assert spans[0].service != "mysvc" + +##how to convert this? Pass in tracer object and just test that? +class TestmariadbPatch(mariadbCore, TracerTestCase): +def setUp(connection, tracer): + super(TestmariadbPatch, connection, tracer).setUp() + patch() + +def tearDown(connection, tracer): + super(TestmariadbPatch, connection, tracer).tearDown() + unpatch() + +def _get_conn_tracer(connection, tracer): + if not self.conn: + self.conn = mariadb.connector.connect(**mariadb_CONFIG) + assert self.conn.is_connected() + # Ensure that the default pin is there, with its default value + pin = Pin.get_from(self.conn) + assert pin + # assert pin.service == 'mariadb' + # Customize the service + # we have to apply it on the existing one since new one won't inherit `app` + pin.clone(tracer=self.tracer).onto(self.conn) + + return self.conn, self.tracer + +def test_patch_unpatch(connection, tracer): + unpatch() + # assert we start unpatched + connection = mariadb.connector.connect(**mariadb_CONFIG) + assert not Pin.get_from(conn) + connection.close() + + patch() + try: + connection = mariadb.connector.connect(**mariadb_CONFIG) + pin = Pin.get_from(conn) + assert pin + pin.clone(service="pin-svc", tracer=self.tracer).onto(conn) + assert connection.is_connected() + + cursor = connection.cursor + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + spans = self.pop_spans() + assert len(spans) == 1 + + span = spans[0] + assert span.service == "pin-svc" + assert span.name == "mariadb.query" + assert span.span_type == "sql" + assert span.error == 0 + assert span.get_metric("out.port") == 3306 + assert_dict_issuperset( + span.meta, + { + "out.host": u"127.0.0.1", + "db.name": u"test", + "db.user": u"test", + }, + ) + assert span.get_tag("sql.query") is None + + finally: + unpatch() + + # assert we finish unpatched + connection = mariadb.connector.connect(**mariadb_CONFIG) + assert not Pin.get_from(connection) + connection.close() + + patch() + +@TracerTestCase.run_in_subprocess(env_overrides=dict(DD_mariadb_SERVICE="mysvc")) +def test_user_specified_service_integration(connection, tracer): + cursor = connection.cursor + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + spans = tracer.pop() + + assert spans[0].service == "mysvc" \ No newline at end of file From 71b35063e4f80aaca159ada342524f72fcc79e37 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Mon, 17 May 2021 11:23:25 -0600 Subject: [PATCH 07/58] committing to merge in master updates --- docker-compose.yml | 11 +++++++---- riotfile.py | 13 ++++--------- 2 files changed, 11 insertions(+), 13 deletions(-) diff --git a/docker-compose.yml b/docker-compose.yml index 22d52ec39a4..ab53ab1b9cf 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -25,8 +25,6 @@ services: - POSTGRES_DB=postgres ports: - "127.0.0.1:5432:5432" - version: '3.1' - mariadb: image: mariadb environment: @@ -36,7 +34,6 @@ services: - MYSQL_PASSWORD=test ports: - "127.0.0.1:3306:3306" - mysql: image: mysql:5.7 environment: @@ -151,5 +148,11 @@ services: - "${TMPDIR:-/tmp/localstack}:/tmp/localstack" - "/var/run/docker.sock:/var/run/docker.sock" + httpbin_local: + image: kennethreitz/httpbin@sha256:2c7abc4803080c22928265744410173b6fea3b898872c01c5fd0f0f9df4a59fb + ports: + - "127.0.0.1:8001:80" + + volumes: - ddagent: + ddagent: \ No newline at end of file diff --git a/riotfile.py b/riotfile.py index a75751254d1..39e9238b734 100644 --- a/riotfile.py +++ b/riotfile.py @@ -795,18 +795,13 @@ def select_pys(min_version=MIN_PYTHON_VERSION, max_version=MAX_PYTHON_VERSION): ), Venv( name="mariadb", - command="pytest {cmdargs} tests/contrib/mariadb", + command="python -m pytest {cmdargs} tests/contrib/mariadb", venvs=[ Venv( - pys=select_pys(max_version="1.0.6"), + pys=select_pys(min_version="3.6"), pkgs={ - "pymongo": [ - ">=1.0.0,<1.0.1", - ">=1.0.1,<1.0.2", - ">=1.0.2,<1.0.3", - ">=1.0.3,<1.0.4", - ">=1.0.4,<1.0.5", - ">=1.0.5,<1.0.6", + "mariadb": [ + ">=1.0.0,<1.1.0", latest, ], }, From b37d210fbaf404812b2ab8336f8f1a563fd3c40f Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Mon, 7 Jun 2021 14:21:56 -0600 Subject: [PATCH 08/58] made all mariadb tests pass --- ddtrace/contrib/mariadb/__init__.py | 3 +- ddtrace/contrib/mariadb/patch.py | 24 +- tests/contrib/mariadb/test_mariadb.py | 629 ++++++++------------ tests/contrib/mariadb/test_mariadbpytest.py | 481 --------------- tests/contrib/mysql/test_mysql.py | 14 +- 5 files changed, 271 insertions(+), 880 deletions(-) delete mode 100644 tests/contrib/mariadb/test_mariadbpytest.py diff --git a/ddtrace/contrib/mariadb/__init__.py b/ddtrace/contrib/mariadb/__init__.py index e5f11d3202d..cc25cfa8b70 100644 --- a/ddtrace/contrib/mariadb/__init__.py +++ b/ddtrace/contrib/mariadb/__init__.py @@ -63,5 +63,6 @@ with require_modules(required_modules) as missing_modules: if not missing_modules: from .patch import patch + from .patch import unpatch - __all__ = ["patch"] + __all__ = ["patch", "unpatch"] diff --git a/ddtrace/contrib/mariadb/patch.py b/ddtrace/contrib/mariadb/patch.py index 015c76c3f4f..2ba574ab83c 100644 --- a/ddtrace/contrib/mariadb/patch.py +++ b/ddtrace/contrib/mariadb/patch.py @@ -7,20 +7,19 @@ from ...ext import db from ...ext import net +from ...utils.formats import asbool +from ...utils.formats import get_env + config._add( "mariadb", dict( + trace_fetch_methods=asbool(get_env("mariadb", "trace_fetch_methods", default=False)), _default_service="mariadb", ), ) -CONN_ATTR_BY_TAG = { - net.TARGET_HOST: "server_host", - net.TARGET_PORT: "server_port", - db.USER: "user", - db.NAME: "database", -} + def patch(): @@ -36,15 +35,16 @@ def unpatch(): def _connect(func, instance, args, kwargs): conn = func(*args, **kwargs) - return patch_conn(conn) - - -def patch_conn(conn): + ##need to pull from args as well at some point + tags = {net.TARGET_HOST: kwargs["host"], + net.TARGET_PORT: kwargs["port"], + db.USER: kwargs["user"], + db.NAME: kwargs["database"], + } - tags = {t: getattr(conn, a) for t, a in CONN_ATTR_BY_TAG.items() if getattr(conn, a, "") != ""} pin = Pin(app="mariadb", tags=tags) # grab the metadata from the conn wrapped = TracedConnection(conn, pin=pin, cfg=config.mariadb) pin.onto(wrapped) - return wrapped + return wrapped \ No newline at end of file diff --git a/tests/contrib/mariadb/test_mariadb.py b/tests/contrib/mariadb/test_mariadb.py index ae81d8f98c6..f73c25f94a2 100644 --- a/tests/contrib/mariadb/test_mariadb.py +++ b/tests/contrib/mariadb/test_mariadb.py @@ -1,51 +1,91 @@ -import mysql - +import pytest +import mariadb +from tests.utils import DummyTracer +from tests.utils import assert_is_measured +from tests.utils import assert_dict_issuperset +from tests.utils import override_config +from tests.utils import TracerTestCase +from ddtrace.contrib.mariadb import patch +from ddtrace.contrib.mariadb import unpatch from ddtrace import Pin from ddtrace.constants import ANALYTICS_SAMPLE_RATE_KEY -from ddtrace.contrib.mariadb.patch import patch -from ddtrace.contrib.mariadb.patch import unpatch -from tests.contrib.config import MYSQL_CONFIG -from tests.opentracer.utils import init_tracer -from tests.utils import TracerTestCase -from tests.utils import assert_dict_issuperset -from tests.utils import assert_is_measured +import unittest -class MySQLCore(object): - """Base test case for MySQL drivers""" - conn = None - def tearDown(self): - super(MySQLCore, self).tearDown() - - # Reuse the connection across tests - if self.conn: - try: - self.conn.ping() - except mysql.InterfaceError: - pass - else: - self.conn.close() - unpatch() - def _get_conn_tracer(self): - # implement me - pass - def test_simple_query(self): - conn, tracer = self._get_conn_tracer() - cursor = conn.cursor() + +@pytest.fixture +def tracer(): + tracer = DummyTracer() + patch() + # Yield to our test + yield tracer + unpatch() + +def get_connection(tracer): + #Some test cases need a connection to be created post-configuration + connection = mariadb.connect( + user="test", + password="test", + host="127.0.0.1", + port=3306, + database="test" + ) + Pin.override(connection, tracer=tracer) + + return connection + + +@pytest.fixture +def connection(tracer): + connection = get_connection(tracer) + + yield connection + connection.close() + + +def test_simple_query(connection, tracer): + cursor = connection.cursor() + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + spans = tracer.pop() + assert len(spans) == 1 + span = spans[0] + assert_is_measured(span) + assert span.service == "mariadb" + assert span.name == "mariadb.query" + assert span.span_type == "sql" + assert span.error == 0 + assert span.get_metric("out.port") == 3306 + + assert_dict_issuperset( + span.meta, + { + "out.host": u"127.0.0.1", + "db.name": u"test", + "db.user": u"test", + }, + ) + +def test_simple_query_fetchall( tracer): + with override_config("mariadb", dict(trace_fetch_methods=True)): + connection = get_connection(tracer) + from ddtrace import config + cursor = connection.cursor() cursor.execute("SELECT 1") rows = cursor.fetchall() assert len(rows) == 1 spans = tracer.pop() - assert len(spans) == 1 + assert len(spans) == 2 span = spans[0] assert_is_measured(span) - assert span.service == "mysql" - assert span.name == "mysql.query" + assert span.service == "mariadb" + assert span.name == "mariadb.query" assert span.span_type == "sql" assert span.error == 0 assert span.get_metric("out.port") == 3306 @@ -57,66 +97,75 @@ def test_simple_query(self): "db.user": u"test", }, ) - - def test_simple_query_fetchll(self): - with self.override_config("dbapi2", dict(trace_fetch_methods=True)): - conn, tracer = self._get_conn_tracer() - cursor = conn.cursor() - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 - spans = tracer.pop() - assert len(spans) == 2 - - span = spans[0] - assert_is_measured(span) - assert span.service == "mysql" - assert span.name == "mysql.query" - assert span.span_type == "sql" - assert span.error == 0 - assert span.get_metric("out.port") == 3306 - assert_dict_issuperset( - span.meta, - { - "out.host": u"127.0.0.1", - "db.name": u"test", - "db.user": u"test", - }, - ) - - assert spans[1].name == "mysql.query.fetchall" - - def test_query_with_several_rows(self): - conn, tracer = self._get_conn_tracer() - cursor = conn.cursor() + assert spans[1].name == "mariadb.query.fetchall" + + +def test_query_with_several_rows(connection, tracer): + cursor = connection.cursor() + query = "SELECT n FROM (SELECT 42 n UNION SELECT 421 UNION SELECT 4210) m" + cursor.execute(query) + rows = cursor.fetchall() + assert len(rows) == 3 + spans = tracer.pop() + assert len(spans) == 1 + span = spans[0] + assert span.get_tag("mariadb.query") is None + +def test_query_with_several_rows_fetchall(tracer): + with override_config("mariadb", dict(trace_fetch_methods=True)): + connection = get_connection(tracer) + cursor = connection.cursor() query = "SELECT n FROM (SELECT 42 n UNION SELECT 421 UNION SELECT 4210) m" cursor.execute(query) rows = cursor.fetchall() assert len(rows) == 3 spans = tracer.pop() - assert len(spans) == 1 + assert len(spans) == 2 span = spans[0] - assert span.get_tag("sql.query") is None - - def test_query_with_several_rows_fetchall(self): - with self.override_config("dbapi2", dict(trace_fetch_methods=True)): - conn, tracer = self._get_conn_tracer() - cursor = conn.cursor() - query = "SELECT n FROM (SELECT 42 n UNION SELECT 421 UNION SELECT 4210) m" - cursor.execute(query) - rows = cursor.fetchall() - assert len(rows) == 3 - spans = tracer.pop() - assert len(spans) == 2 - span = spans[0] - assert span.get_tag("sql.query") is None - assert spans[1].name == "mysql.query.fetchall" - - def test_query_many(self): + assert span.get_tag("mariadb.query") is None + assert spans[1].name == "mariadb.query.fetchall" + +def test_query_many(connection, tracer): + # tests that the executemany method is correctly wrapped. + tracer.enabled = False + cursor = connection.cursor() + + cursor.execute( + """ + create table if not exists dummy ( + dummy_key VARCHAR(32) PRIMARY KEY, + dummy_value TEXT NOT NULL)""" + ) + tracer.enabled = True + + stmt = "INSERT INTO dummy (dummy_key, dummy_value) VALUES (%s, %s)" + data = [ + ("foo", "this is foo"), + ("bar", "this is bar"), + ] + cursor.executemany(stmt, data) + query = "SELECT dummy_key, dummy_value FROM dummy ORDER BY dummy_key" + cursor.execute(query) + rows = cursor.fetchall() + assert len(rows) == 2 + assert rows[0][0] == "bar" + assert rows[0][1] == "this is bar" + assert rows[1][0] == "foo" + assert rows[1][1] == "this is foo" + + spans = tracer.pop() + assert len(spans) == 2 + span = spans[-1] + assert span.get_tag("mariadb.query") is None + cursor.execute("drop table if exists dummy") + +def test_query_many_fetchall(tracer): + with override_config("mariadb", dict(trace_fetch_methods=True)): + connection = get_connection(tracer) + # tests that the executemany method is correctly wrapped. - conn, tracer = self._get_conn_tracer() tracer.enabled = False - cursor = conn.cursor() + cursor = connection.cursor() cursor.execute( """ @@ -142,330 +191,152 @@ def test_query_many(self): assert rows[1][1] == "this is foo" spans = tracer.pop() - assert len(spans) == 2 + assert len(spans) == 3 span = spans[-1] - assert span.get_tag("sql.query") is None + assert span.get_tag("mariadb.query") is None cursor.execute("drop table if exists dummy") - def test_query_many_fetchall(self): - with self.override_config("dbapi2", dict(trace_fetch_methods=True)): - # tests that the executemany method is correctly wrapped. - conn, tracer = self._get_conn_tracer() - tracer.enabled = False - cursor = conn.cursor() - - cursor.execute( - """ - create table if not exists dummy ( - dummy_key VARCHAR(32) PRIMARY KEY, - dummy_value TEXT NOT NULL)""" - ) - tracer.enabled = True - - stmt = "INSERT INTO dummy (dummy_key, dummy_value) VALUES (%s, %s)" - data = [ - ("foo", "this is foo"), - ("bar", "this is bar"), - ] - cursor.executemany(stmt, data) - query = "SELECT dummy_key, dummy_value FROM dummy ORDER BY dummy_key" - cursor.execute(query) - rows = cursor.fetchall() - assert len(rows) == 2 - assert rows[0][0] == "bar" - assert rows[0][1] == "this is bar" - assert rows[1][0] == "foo" - assert rows[1][1] == "this is foo" - - spans = tracer.pop() - assert len(spans) == 3 - span = spans[-1] - assert span.get_tag("sql.query") is None - cursor.execute("drop table if exists dummy") - - assert spans[2].name == "mysql.query.fetchall" - - def test_query_proc(self): - conn, tracer = self._get_conn_tracer() - - # create a procedure - tracer.enabled = False - cursor = conn.cursor() - cursor.execute("DROP PROCEDURE IF EXISTS sp_sum") - cursor.execute( - """ - CREATE PROCEDURE sp_sum (IN p1 INTEGER, IN p2 INTEGER, OUT p3 INTEGER) - BEGIN - SET p3 := p1 + p2; - END;""" - ) - - tracer.enabled = True - proc = "sp_sum" - data = (40, 2, None) - output = cursor.callproc(proc, data) - assert len(output) == 3 - assert output[2] == 42 - - spans = tracer.pop() - assert spans, spans - - # number of spans depends on MySQL implementation details, - # typically, internal calls to execute, but at least we - # can expect the last closed span to be our proc. - span = spans[len(spans) - 1] - assert_is_measured(span) - assert span.service == "mysql" - assert span.name == "mysql.query" - assert span.span_type == "sql" - assert span.error == 0 - assert span.get_metric("out.port") == 3306 - assert_dict_issuperset( - span.meta, - { - "out.host": u"127.0.0.1", - "db.name": u"test", - "db.user": u"test", - }, - ) - assert span.get_tag("sql.query") is None - - def test_simple_query_ot(self): - """OpenTracing version of test_simple_query.""" - conn, tracer = self._get_conn_tracer() + assert spans[2].name == "mariadb.query.fetchall" - ot_tracer = init_tracer("mysql_svc", tracer) +def test_query_proc(connection, tracer): - with ot_tracer.start_active_span("mysql_op"): - cursor = conn.cursor() - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 - - spans = tracer.pop() - assert len(spans) == 2 - - ot_span, dd_span = spans - - # confirm parenting - assert ot_span.parent_id is None - assert dd_span.parent_id == ot_span.span_id - - assert ot_span.service == "mysql_svc" - assert ot_span.name == "mysql_op" - - assert_is_measured(dd_span) - assert dd_span.service == "mysql" - assert dd_span.name == "mysql.query" - assert dd_span.span_type == "sql" - assert dd_span.error == 0 - assert dd_span.get_metric("out.port") == 3306 - assert_dict_issuperset( - dd_span.meta, - { - "out.host": u"127.0.0.1", - "db.name": u"test", - "db.user": u"test", - }, - ) - - def test_simple_query_ot_fetchall(self): - """OpenTracing version of test_simple_query.""" - with self.override_config("dbapi2", dict(trace_fetch_methods=True)): - conn, tracer = self._get_conn_tracer() - - ot_tracer = init_tracer("mysql_svc", tracer) - - with ot_tracer.start_active_span("mysql_op"): - cursor = conn.cursor() - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 - - spans = tracer.pop() - assert len(spans) == 3 - - ot_span, dd_span, fetch_span = spans - - # confirm parenting - assert ot_span.parent_id is None - assert dd_span.parent_id == ot_span.span_id - - assert ot_span.service == "mysql_svc" - assert ot_span.name == "mysql_op" - - assert_is_measured(dd_span) - assert dd_span.service == "mysql" - assert dd_span.name == "mysql.query" - assert dd_span.span_type == "sql" - assert dd_span.error == 0 - assert dd_span.get_metric("out.port") == 3306 - assert_dict_issuperset( - dd_span.meta, - { - "out.host": u"127.0.0.1", - "db.name": u"test", - "db.user": u"test", - }, - ) - - assert fetch_span.name == "mysql.query.fetchall" - - def test_commit(self): - conn, tracer = self._get_conn_tracer() - conn.commit() - spans = tracer.pop() - assert len(spans) == 1 - span = spans[0] - assert span.service == "mysql" - assert span.name == "mysql.connection.commit" - - def test_rollback(self): - conn, tracer = self._get_conn_tracer() - conn.rollback() + # create a procedure + tracer.enabled = False + cursor = connection.cursor() + cursor.execute("DROP PROCEDURE IF EXISTS sp_sum") + cursor.execute( + """ + CREATE PROCEDURE sp_sum (IN p1 INTEGER, IN p2 INTEGER, OUT p3 INTEGER) + BEGIN + SET p3 := p1 + p2; + END;""" + ) + + tracer.enabled = True + proc = "sp_sum" + data = (40, 2, None) + cursor.callproc(proc, data) + + + spans = tracer.pop() + assert spans, spans + + # number of spans depends on mariadb implementation details, + # typically, internal calls to execute, but at least we + # can expect the last closed span to be our proc. + span = spans[len(spans) - 1] + assert_is_measured(span) + assert span.service == "mariadb" + assert span.name == "mariadb.query" + assert span.span_type == "sql" + assert span.error == 0 + assert span.get_metric("out.port") == 3306 + assert_dict_issuperset( + span.meta, + { + "out.host": u"127.0.0.1", + "db.name": u"test", + "db.user": u"test", + }, + ) + assert span.get_tag("mariadb.query") is None + +def test_commit(connection, tracer): + connection.commit() + spans = tracer.pop() + assert len(spans) == 1 + span = spans[0] + assert span.service == "mariadb" + assert span.name == "mariadb.connection.commit" + +def test_rollback(connection, tracer): + connection.rollback() + spans = tracer.pop() + assert len(spans) == 1 + span = spans[0] + assert span.service == "mariadb" + assert span.name == "mariadb.connection.rollback" + +def test_analytics_default(connection, tracer): + cursor = connection.cursor() + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + spans = tracer.pop() + assert len(spans) == 1 + span = spans[0] + assert span.get_metric(ANALYTICS_SAMPLE_RATE_KEY) is None + +def test_analytics_with_rate(connection, tracer): + with override_config("mariadb", dict(analytics_enabled=True, analytics_sample_rate=0.5)): + cursor = connection.cursor() + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 spans = tracer.pop() assert len(spans) == 1 span = spans[0] - assert span.service == "mysql" - assert span.name == "mysql.connection.rollback" + assert span.get_metric(ANALYTICS_SAMPLE_RATE_KEY) == 0.5 - def test_analytics_default(self): - conn, tracer = self._get_conn_tracer() - cursor = conn.cursor() +def test_analytics_without_rate(connection, tracer): + with override_config("mariadb", dict(analytics_enabled=True)): + cursor = connection.cursor() cursor.execute("SELECT 1") rows = cursor.fetchall() assert len(rows) == 1 spans = tracer.pop() - self.assertEqual(len(spans), 1) - span = spans[0] - self.assertIsNone(span.get_metric(ANALYTICS_SAMPLE_RATE_KEY)) - - def test_analytics_with_rate(self): - with self.override_config("dbapi2", dict(analytics_enabled=True, analytics_sample_rate=0.5)): - conn, tracer = self._get_conn_tracer() - cursor = conn.cursor() - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 - spans = tracer.pop() - - self.assertEqual(len(spans), 1) - span = spans[0] - self.assertEqual(span.get_metric(ANALYTICS_SAMPLE_RATE_KEY), 0.5) - - def test_analytics_without_rate(self): - with self.override_config("dbapi2", dict(analytics_enabled=True)): - conn, tracer = self._get_conn_tracer() - cursor = conn.cursor() - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 - spans = tracer.pop() - - self.assertEqual(len(spans), 1) - span = spans[0] - self.assertEqual(span.get_metric(ANALYTICS_SAMPLE_RATE_KEY), 1.0) - - @TracerTestCase.run_in_subprocess(env_overrides=dict(DD_SERVICE="mysvc")) - def test_user_specified_service(self): - """ - When a user specifies a service for the app - The mysql integration should not use it. - """ - # Ensure that the service name was configured - from ddtrace import config + assert len(spans) == 1 - assert config.service == "mysvc" + span = spans[0] + assert span.get_metric(ANALYTICS_SAMPLE_RATE_KEY) == 1.0 - conn, tracer = self._get_conn_tracer() - cursor = conn.cursor() - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 - spans = tracer.pop() - assert spans[0].service != "mysvc" -class TestMysqlPatch(MySQLCore, TracerTestCase): +class TestMariadbPatch(TracerTestCase): def setUp(self): - super(TestMysqlPatch, self).setUp() + super(TestMariadbPatch, self).setUp() patch() + self.connection = mariadb.connect( + user="test", + password="test", + host="127.0.0.1", + port=3306, + database="test" + ) + Pin.override(self.connection, tracer=self.tracer) - def tearDown(self): - super(TestMysqlPatch, self).tearDown() - unpatch() + @TracerTestCase.run_in_subprocess(env_overrides=dict(DD_SERVICE="mysvc")) + def test_user_specified_service(self): + """ + When a user specifies a service for the app + The mariadb integration should not use it. + """ + # Ensure that the service name was configured + from ddtrace import config - def _get_conn_tracer(self): - if not self.conn: - self.conn = mysql.connector.connect(**MYSQL_CONFIG) - assert self.conn.is_connected() - # Ensure that the default pin is there, with its default value - pin = Pin.get_from(self.conn) - assert pin - # assert pin.service == 'mysql' - # Customize the service - # we have to apply it on the existing one since new one won't inherit `app` - pin.clone(tracer=self.tracer).onto(self.conn) - - return self.conn, self.tracer - - def test_patch_unpatch(self): - unpatch() - # assert we start unpatched - conn = mysql.connector.connect(**MYSQL_CONFIG) - assert not Pin.get_from(conn) - conn.close() + assert config.service == "mysvc" - patch() - try: - conn = mysql.connector.connect(**MYSQL_CONFIG) - pin = Pin.get_from(conn) - assert pin - pin.clone(service="pin-svc", tracer=self.tracer).onto(conn) - assert conn.is_connected() - - cursor = conn.cursor() + cursor = self.connection.cursor() cursor.execute("SELECT 1") rows = cursor.fetchall() assert len(rows) == 1 - spans = self.pop_spans() - assert len(spans) == 1 - - span = spans[0] - assert span.service == "pin-svc" - assert span.name == "mysql.query" - assert span.span_type == "sql" - assert span.error == 0 - assert span.get_metric("out.port") == 3306 - assert_dict_issuperset( - span.meta, - { - "out.host": u"127.0.0.1", - "db.name": u"test", - "db.user": u"test", - }, - ) - assert span.get_tag("sql.query") is None - - finally: - unpatch() - - # assert we finish unpatched - conn = mysql.connector.connect(**MYSQL_CONFIG) - assert not Pin.get_from(conn) - conn.close() + spans = self.tracer.pop() + + assert spans[0].service != "mysvc" + + def tearDown(self): + super(TestMariadbPatch, self).tearDown() + unpatch() + self.connection.close() - patch() - @TracerTestCase.run_in_subprocess(env_overrides=dict(DD_MYSQL_SERVICE="mysvc")) + @TracerTestCase.run_in_subprocess(env_overrides=dict(DD_MARIADB_SERVICE="mysvc")) def test_user_specified_service_integration(self): - conn, tracer = self._get_conn_tracer() - cursor = conn.cursor() + cursor = self.connection.cursor() cursor.execute("SELECT 1") rows = cursor.fetchall() assert len(rows) == 1 - spans = tracer.pop() - - assert spans[0].service == "mysvc" + spans = self.tracer.pop() + assert spans[0].service == "mysvc" \ No newline at end of file diff --git a/tests/contrib/mariadb/test_mariadbpytest.py b/tests/contrib/mariadb/test_mariadbpytest.py deleted file mode 100644 index d5c7d6e8a70..00000000000 --- a/tests/contrib/mariadb/test_mariadbpytest.py +++ /dev/null @@ -1,481 +0,0 @@ -import pytest -import mariadb -from tests.utils import DummyTracer -from tests.utils import assert_is_measured -from tests.utils import assert_dict_issuperset - - - -@pytest.fixture -def tracer(): - tracer = DummyTracer() - # Yield to our test - yield tracer - tracer.pop() - - -@pytest.fixture -def connection(tracer): - connection = mariadb.connect( - user="user", - password="user", - host="127.0.0.1", - port=3306, - database="employees" - ) - Pin.override(connection, tracer=tracer) -#need to figure out where the code to make the db goes, previously it went in an init -#db file but now maybe i should just use the connection to create a database here? -# CREATE DATABASE IF NOT EXISTS `test`; -# GRANT ALL ON `test`.* TO 'user'@'%'; - yield connection - connection.close() - - -def test_simple_query(connection, tracer): - cursor = connection.cursor() - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 - spans = tracer.pop() - assert len(spans) == 1 - span = spans[0] - assert_is_measured(span) - assert span.service == "mariadb" - assert span.name == "mariadb.query" - assert span.span_type == "sql" - assert span.error == 0 - assert span.get_metric("out.port") == 3306 - assert_dict_issuperset( - span.meta, - { - "out.host": u"127.0.0.1", - "db.name": u"test", - "db.user": u"test", - }, - ) - -def test_simple_query_fetchll(connection, tracer): - ##Overide the tracer rather than the self object (how it's done in test_mysql.py) - tracer.override_config("dbapi2", dict(trace_fetch_methods=True)) - cursor = connection.cursor() - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 - spans = tracer.pop() - assert len(spans) == 2 - - span = spans[0] - assert_is_measured(span) - assert span.service == "mariadb" - assert span.name == "mariadb.query" - assert span.span_type == "sql" - assert span.error == 0 - assert span.get_metric("out.port") == 3306 - assert_dict_issuperset( - span.meta, - { - "out.host": u"127.0.0.1", - "db.name": u"test", - "db.user": u"test", - }, - ) - - assert spans[1].name == "mariadb.query.fetchall" - -def test_simple_query_fetchll(connection, tracer): - with self.override_config("dbapi2", dict(trace_fetch_methods=True)): - cursor = connection.cursor - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 - spans = tracer.pop() - assert len(spans) == 2 - - span = spans[0] - assert_is_measured(span) - assert span.service == "mariadb" - assert span.name == "mariadb.query" - assert span.span_type == "sql" - assert span.error == 0 - assert span.get_metric("out.port") == 3306 - assert_dict_issuperset( - span.meta, - { - "out.host": u"127.0.0.1", - "db.name": u"test", - "db.user": u"test", - }, - ) - - assert spans[1].name == "mariadb.query.fetchall" - -def test_query_with_several_rows(connection, tracer): - cursor = connection.cursor() - query = "SELECT n FROM (SELECT 42 n UNION SELECT 421 UNION SELECT 4210) m" - cursor.execute(query) - rows = cursor.fetchall() - assert len(rows) == 3 - spans = tracer.pop() - assert len(spans) == 1 - span = spans[0] - assert span.get_tag("sql.query") is None - -def test_query_with_several_rows_fetchall(connection, tracer): - with self.override_config("dbapi2", dict(trace_fetch_methods=True)): - cursor = connection.cursor - query = "SELECT n FROM (SELECT 42 n UNION SELECT 421 UNION SELECT 4210) m" - cursor.execute(query) - rows = cursor.fetchall() - assert len(rows) == 3 - spans = tracer.pop() - assert len(spans) == 2 - span = spans[0] - assert span.get_tag("sql.query") is None - assert spans[1].name == "mariadb.query.fetchall" - -def test_query_many(connection, tracer): - # tests that the executemany method is correctly wrapped. - tracer.enabled = False - cursor = connection.cursor - - cursor.execute( - """ - create table if not exists dummy ( - dummy_key VARCHAR(32) PRIMARY KEY, - dummy_value TEXT NOT NULL)""" - ) - tracer.enabled = True - - stmt = "INSERT INTO dummy (dummy_key, dummy_value) VALUES (%s, %s)" - data = [ - ("foo", "this is foo"), - ("bar", "this is bar"), - ] - cursor.executemany(stmt, data) - query = "SELECT dummy_key, dummy_value FROM dummy ORDER BY dummy_key" - cursor.execute(query) - rows = cursor.fetchall() - assert len(rows) == 2 - assert rows[0][0] == "bar" - assert rows[0][1] == "this is bar" - assert rows[1][0] == "foo" - assert rows[1][1] == "this is foo" - - spans = tracer.pop() - assert len(spans) == 2 - span = spans[-1] - assert span.get_tag("sql.query") is None - cursor.execute("drop table if exists dummy") - -def test_query_many_fetchall(connection, tracer): - with self.override_config("dbapi2", dict(trace_fetch_methods=True)): - # tests that the executemany method is correctly wrapped. - tracer.enabled = False - cursor = connection.cursor - - cursor.execute( - """ - create table if not exists dummy ( - dummy_key VARCHAR(32) PRIMARY KEY, - dummy_value TEXT NOT NULL)""" - ) - tracer.enabled = True - - stmt = "INSERT INTO dummy (dummy_key, dummy_value) VALUES (%s, %s)" - data = [ - ("foo", "this is foo"), - ("bar", "this is bar"), - ] - cursor.executemany(stmt, data) - query = "SELECT dummy_key, dummy_value FROM dummy ORDER BY dummy_key" - cursor.execute(query) - rows = cursor.fetchall() - assert len(rows) == 2 - assert rows[0][0] == "bar" - assert rows[0][1] == "this is bar" - assert rows[1][0] == "foo" - assert rows[1][1] == "this is foo" - - spans = tracer.pop() - assert len(spans) == 3 - span = spans[-1] - assert span.get_tag("sql.query") is None - cursor.execute("drop table if exists dummy") - - assert spans[2].name == "mariadb.query.fetchall" - -def test_query_proc(connection, tracer): - - # create a procedure - tracer.enabled = False - cursor = connection.cursor - cursor.execute("DROP PROCEDURE IF EXISTS sp_sum") - cursor.execute( - """ - CREATE PROCEDURE sp_sum (IN p1 INTEGER, IN p2 INTEGER, OUT p3 INTEGER) - BEGIN - SET p3 := p1 + p2; - END;""" - ) - - tracer.enabled = True - proc = "sp_sum" - data = (40, 2, None) - output = cursor.callproc(proc, data) - assert len(output) == 3 - assert output[2] == 42 - - spans = tracer.pop() - assert spans, spans - - # number of spans depends on mariadb implementation details, - # typically, internal calls to execute, but at least we - # can expect the last closed span to be our proc. - span = spans[len(spans) - 1] - assert_is_measured(span) - assert span.service == "mariadb" - assert span.name == "mariadb.query" - assert span.span_type == "sql" - assert span.error == 0 - assert span.get_metric("out.port") == 3306 - assert_dict_issuperset( - span.meta, - { - "out.host": u"127.0.0.1", - "db.name": u"test", - "db.user": u"test", - }, - ) - assert span.get_tag("sql.query") is None - -def test_simple_query_ot(connection, tracer): - """OpenTracing version of test_simple_query.""" - - ot_tracer = init_tracer("mariadb_svc", tracer) - - with ot_tracer.start_active_span("mariadb_op"): - cursor = connection.cursor - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 - - spans = tracer.pop() - assert len(spans) == 2 - - ot_span, dd_span = spans - - # confirm parenting - assert ot_span.parent_id is None - assert dd_span.parent_id == ot_span.span_id - - assert ot_span.service == "mariadb_svc" - assert ot_span.name == "mariadb_op" - - assert_is_measured(dd_span) - assert dd_span.service == "mariadb" - assert dd_span.name == "mariadb.query" - assert dd_span.span_type == "sql" - assert dd_span.error == 0 - assert dd_span.get_metric("out.port") == 3306 - assert_dict_issuperset( - dd_span.meta, - { - "out.host": u"127.0.0.1", - "db.name": u"test", - "db.user": u"test", - }, - ) - -def test_simple_query_ot_fetchall(connection, tracer): - """OpenTracing version of test_simple_query.""" - with self.override_config("dbapi2", dict(trace_fetch_methods=True)): - - ot_tracer = init_tracer("mariadb_svc", tracer) - - with ot_tracer.start_active_span("mariadb_op"): - cursor = connection.cursor - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 - - spans = tracer.pop() - assert len(spans) == 3 - - ot_span, dd_span, fetch_span = spans - - # confirm parenting - assert ot_span.parent_id is None - assert dd_span.parent_id == ot_span.span_id - - assert ot_span.service == "mariadb_svc" - assert ot_span.name == "mariadb_op" - - assert_is_measured(dd_span) - assert dd_span.service == "mariadb" - assert dd_span.name == "mariadb.query" - assert dd_span.span_type == "sql" - assert dd_span.error == 0 - assert dd_span.get_metric("out.port") == 3306 - assert_dict_issuperset( - dd_span.meta, - { - "out.host": u"127.0.0.1", - "db.name": u"test", - "db.user": u"test", - }, - ) - - assert fetch_span.name == "mariadb.query.fetchall" - -def test_commit(connection, tracer): - conn.commit() - spans = tracer.pop() - assert len(spans) == 1 - span = spans[0] - assert span.service == "mariadb" - assert span.name == "mariadb.connection.commit" - -def test_rollback(connection, tracer): - conn.rollback() - spans = tracer.pop() - assert len(spans) == 1 - span = spans[0] - assert span.service == "mariadb" - assert span.name == "mariadb.connection.rollback" - -def test_analytics_default(connection, tracer): - cursor = connection.cursor - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 - spans = tracer.pop() - - self.assertEqual(len(spans), 1) - span = spans[0] - self.assertIsNone(span.get_metric(ANALYTICS_SAMPLE_RATE_KEY)) - -def test_analytics_with_rate(connection, tracer): - with self.override_config("dbapi2", dict(analytics_enabled=True, analytics_sample_rate=0.5)): - cursor = connection.cursor - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 - spans = tracer.pop() - - self.assertEqual(len(spans), 1) - span = spans[0] - self.assertEqual(span.get_metric(ANALYTICS_SAMPLE_RATE_KEY), 0.5) - -def test_analytics_without_rate(connection, tracer): - with self.override_config("dbapi2", dict(analytics_enabled=True)): - cursor = connection.cursor - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 - spans = tracer.pop() - - self.assertEqual(len(spans), 1) - span = spans[0] - self.assertEqual(span.get_metric(ANALYTICS_SAMPLE_RATE_KEY), 1.0) - -@TracerTestCase.run_in_subprocess(env_overrides=dict(DD_SERVICE="mysvc")) -def test_user_specified_service(connection, tracer): - """ - When a user specifies a service for the app - The mariadb integration should not use it. - """ - # Ensure that the service name was configured - from ddtrace import config - - assert config.service == "mysvc" - - cursor = connection.cursor - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 - spans = tracer.pop() - - assert spans[0].service != "mysvc" - -##how to convert this? Pass in tracer object and just test that? -class TestmariadbPatch(mariadbCore, TracerTestCase): -def setUp(connection, tracer): - super(TestmariadbPatch, connection, tracer).setUp() - patch() - -def tearDown(connection, tracer): - super(TestmariadbPatch, connection, tracer).tearDown() - unpatch() - -def _get_conn_tracer(connection, tracer): - if not self.conn: - self.conn = mariadb.connector.connect(**mariadb_CONFIG) - assert self.conn.is_connected() - # Ensure that the default pin is there, with its default value - pin = Pin.get_from(self.conn) - assert pin - # assert pin.service == 'mariadb' - # Customize the service - # we have to apply it on the existing one since new one won't inherit `app` - pin.clone(tracer=self.tracer).onto(self.conn) - - return self.conn, self.tracer - -def test_patch_unpatch(connection, tracer): - unpatch() - # assert we start unpatched - connection = mariadb.connector.connect(**mariadb_CONFIG) - assert not Pin.get_from(conn) - connection.close() - - patch() - try: - connection = mariadb.connector.connect(**mariadb_CONFIG) - pin = Pin.get_from(conn) - assert pin - pin.clone(service="pin-svc", tracer=self.tracer).onto(conn) - assert connection.is_connected() - - cursor = connection.cursor - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 - spans = self.pop_spans() - assert len(spans) == 1 - - span = spans[0] - assert span.service == "pin-svc" - assert span.name == "mariadb.query" - assert span.span_type == "sql" - assert span.error == 0 - assert span.get_metric("out.port") == 3306 - assert_dict_issuperset( - span.meta, - { - "out.host": u"127.0.0.1", - "db.name": u"test", - "db.user": u"test", - }, - ) - assert span.get_tag("sql.query") is None - - finally: - unpatch() - - # assert we finish unpatched - connection = mariadb.connector.connect(**mariadb_CONFIG) - assert not Pin.get_from(connection) - connection.close() - - patch() - -@TracerTestCase.run_in_subprocess(env_overrides=dict(DD_mariadb_SERVICE="mysvc")) -def test_user_specified_service_integration(connection, tracer): - cursor = connection.cursor - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 - spans = tracer.pop() - - assert spans[0].service == "mysvc" \ No newline at end of file diff --git a/tests/contrib/mysql/test_mysql.py b/tests/contrib/mysql/test_mysql.py index 4a536311fbc..d80b3654482 100644 --- a/tests/contrib/mysql/test_mysql.py +++ b/tests/contrib/mysql/test_mysql.py @@ -58,8 +58,8 @@ def test_simple_query(self): }, ) - def test_simple_query_fetchll(self): - with self.override_config("mysql", dict(trace_fetch_methods=True)): + def test_simple_query_fetchall(self): + with self.override_config("dbapi2", dict(trace_fetch_methods=True)): conn, tracer = self._get_conn_tracer() cursor = conn.cursor() cursor.execute("SELECT 1") @@ -99,7 +99,7 @@ def test_query_with_several_rows(self): assert span.get_tag("sql.query") is None def test_query_with_several_rows_fetchall(self): - with self.override_config("mysql", dict(trace_fetch_methods=True)): + with self.override_config("dbapi2", dict(trace_fetch_methods=True)): conn, tracer = self._get_conn_tracer() cursor = conn.cursor() query = "SELECT n FROM (SELECT 42 n UNION SELECT 421 UNION SELECT 4210) m" @@ -148,7 +148,7 @@ def test_query_many(self): cursor.execute("drop table if exists dummy") def test_query_many_fetchall(self): - with self.override_config("mysql", dict(trace_fetch_methods=True)): + with self.override_config("dbapi2", dict(trace_fetch_methods=True)): # tests that the executemany method is correctly wrapped. conn, tracer = self._get_conn_tracer() tracer.enabled = False @@ -271,7 +271,7 @@ def test_simple_query_ot(self): def test_simple_query_ot_fetchall(self): """OpenTracing version of test_simple_query.""" - with self.override_config("mysql", dict(trace_fetch_methods=True)): + with self.override_config("dbapi2", dict(trace_fetch_methods=True)): conn, tracer = self._get_conn_tracer() ot_tracer = init_tracer("mysql_svc", tracer) @@ -342,7 +342,7 @@ def test_analytics_default(self): self.assertIsNone(span.get_metric(ANALYTICS_SAMPLE_RATE_KEY)) def test_analytics_with_rate(self): - with self.override_config("mysql", dict(analytics_enabled=True, analytics_sample_rate=0.5)): + with self.override_config("dbapi2", dict(analytics_enabled=True, analytics_sample_rate=0.5)): conn, tracer = self._get_conn_tracer() cursor = conn.cursor() cursor.execute("SELECT 1") @@ -355,7 +355,7 @@ def test_analytics_with_rate(self): self.assertEqual(span.get_metric(ANALYTICS_SAMPLE_RATE_KEY), 0.5) def test_analytics_without_rate(self): - with self.override_config("mysql", dict(analytics_enabled=True)): + with self.override_config("dbapi2", dict(analytics_enabled=True)): conn, tracer = self._get_conn_tracer() cursor = conn.cursor() cursor.execute("SELECT 1") From 6001351860a4ce3683857a9b0d63305da77d1d03 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Mon, 7 Jun 2021 15:57:44 -0600 Subject: [PATCH 09/58] added first snapshot test --- tests/contrib/mariadb/test_mariadb.py | 13 +++++++++-- ...st_mariadb.test_simple_query_snapshot.snap | 22 +++++++++++++++++++ 2 files changed, 33 insertions(+), 2 deletions(-) create mode 100644 tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_snapshot.snap diff --git a/tests/contrib/mariadb/test_mariadb.py b/tests/contrib/mariadb/test_mariadb.py index f73c25f94a2..55d34110dbf 100644 --- a/tests/contrib/mariadb/test_mariadb.py +++ b/tests/contrib/mariadb/test_mariadb.py @@ -8,8 +8,9 @@ from ddtrace.contrib.mariadb import patch from ddtrace.contrib.mariadb import unpatch from ddtrace import Pin +from ddtrace import tracer as global_tracer from ddtrace.constants import ANALYTICS_SAMPLE_RATE_KEY - +from tests.utils import snapshot import unittest @@ -339,4 +340,12 @@ def test_user_specified_service_integration(self): rows = cursor.fetchall() assert len(rows) == 1 spans = self.tracer.pop() - assert spans[0].service == "mysvc" \ No newline at end of file + assert spans[0].service == "mysvc" + +@snapshot(include_tracer=True) +def test_simple_query_snapshot(tracer): + connection = get_connection(tracer) + cursor = connection.cursor() + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 \ No newline at end of file diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_snapshot.snap new file mode 100644 index 00000000000..7ea8761d6af --- /dev/null +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_snapshot.snap @@ -0,0 +1,22 @@ +[[{"name" "mariadb.query" + "service" "mariadb" + "resource" "SELECT 1" + "type" "sql" + "error" 0 + "span_id" 0 + "trace_id" 0 + "parent_id" nil + "start" 1623100643599560800 + "duration" 767400 + "meta" {"runtime-id" "fd4ce2f440a044538bd1a0dc3cb9b907" + "out.host" "127.0.0.1" + "db.user" "test" + "db.name" "test"} + "metrics" {"_dd.agent_psr" 1.0 + "_dd.measured" 1 + "_sampling_priority_v1" 1 + "system.pid" 2243 + "out.port" 3306 + "db.rowcount" 0 + "sql.rows" 0 + "_dd.tracer_kr" 1.0}}]] From 3e32f6ff2490d9240bb15a94e14fa38874faa3b3 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Mon, 14 Jun 2021 13:18:44 -0600 Subject: [PATCH 10/58] removed print statement and added more snapshot tests for mariadb integration --- ddtrace/__init__.py | 2 +- tests/contrib/mariadb/test_mariadb.py | 39 ++++++++++++++++++++++++++- 2 files changed, 39 insertions(+), 2 deletions(-) diff --git a/ddtrace/__init__.py b/ddtrace/__init__.py index fbca7afaa64..c6cff44a38d 100644 --- a/ddtrace/__init__.py +++ b/ddtrace/__init__.py @@ -8,7 +8,7 @@ from .tracer import Tracer # noqa: E402 from .utils.deprecation import deprecated # noqa: E402 -print("Hello tracing") + try: __version__ = pkg_resources.get_distribution(__name__).version diff --git a/tests/contrib/mariadb/test_mariadb.py b/tests/contrib/mariadb/test_mariadb.py index 55d34110dbf..34bbc3acbe7 100644 --- a/tests/contrib/mariadb/test_mariadb.py +++ b/tests/contrib/mariadb/test_mariadb.py @@ -348,4 +348,41 @@ def test_simple_query_snapshot(tracer): cursor = connection.cursor() cursor.execute("SELECT 1") rows = cursor.fetchall() - assert len(rows) == 1 \ No newline at end of file + assert len(rows) == 1 + +@snapshot(include_tracer=True) +def test_simple_query_fetchall( tracer): + with override_config("mariadb", dict(trace_fetch_methods=True)): + connection = get_connection(tracer) + cursor = connection.cursor() + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 + + +@snapshot(include_tracer=True) +def test_commit_snapshot(tracer): + connection = get_connection(tracer) + connection.commit() + +@snapshot(include_tracer=True) +def test_query_proc(tracer): + connection = get_connection(tracer) + # create a procedure + tracer.enabled = False + cursor = connection.cursor() + cursor.execute("DROP PROCEDURE IF EXISTS sp_sum") + cursor.execute( + """ + CREATE PROCEDURE sp_sum (IN p1 INTEGER, IN p2 INTEGER, OUT p3 INTEGER) + BEGIN + SET p3 := p1 + p2; + END;""" + ) + + tracer.enabled = True + proc = "sp_sum" + data = (40, 2, None) + cursor.callproc(proc, data) + + From bfd87e924c014bb68f69fa7672c2ceebfbc6ca58 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Mon, 14 Jun 2021 15:19:04 -0600 Subject: [PATCH 11/58] updated docs to include mariadb integration and made documentation in __init__.py file for mariadb correct --- ddtrace/contrib/mariadb/__init__.py | 32 ++++++++++++++--------------- docs/index.rst | 2 ++ docs/integrations.rst | 7 +++++++ 3 files changed, 25 insertions(+), 16 deletions(-) diff --git a/ddtrace/contrib/mariadb/__init__.py b/ddtrace/contrib/mariadb/__init__.py index cc25cfa8b70..d20038b9d1c 100644 --- a/ddtrace/contrib/mariadb/__init__.py +++ b/ddtrace/contrib/mariadb/__init__.py @@ -1,63 +1,63 @@ """ -The mysql integration instruments the mysql library to trace MySQL queries. +The integration instruments the mariadb library to trace mariadb queries. Enabling ~~~~~~~~ -The mysql integration is enabled automatically when using +The mariadb integration is enabled automatically when using :ref:`ddtrace-run` or :ref:`patch_all()`. Or use :ref:`patch()` to manually enable the integration:: from ddtrace import patch - patch(mysql=True) + patch(mariadb=True) Global Configuration ~~~~~~~~~~~~~~~~~~~~ -.. py:data:: ddtrace.config.mysql["service"] +.. py:data:: ddtrace.config.mariadb["service"] - The service name reported by default for mysql spans. + The service name reported by default for mariadb spans. - This option can also be set with the ``DD_MYSQL_SERVICE`` environment + This option can also be set with the ``DD_MARIADB_SERVICE`` environment variable. - Default: ``"mysql"`` + Default: ``"mariadb"`` Instance Configuration ~~~~~~~~~~~~~~~~~~~~~~ -To configure the mysql integration on an per-connection basis use the +To configure the mariadb integration on an per-connection basis use the ``Pin`` API:: from ddtrace import Pin - # Make sure to import mysql.connector and not the 'connect' function, + # Make sure to import mariadb.connector and not the 'connect' function, # otherwise you won't have access to the patched version - import mysql.connector + import mariadb.connector # This will report a span with the default settings - conn = mysql.connector.connect(user="alice", password="b0b", host="localhost", port=3306, database="test") + conn = mariadb.connector.connect(user="alice", password="b0b", host="localhost", port=3306, database="test") # Use a pin to override the service name for this connection. - Pin.override(conn, service='mysql-users') + Pin.override(conn, service='mariadb-users') cursor = conn.cursor() cursor.execute("SELECT 6*7 AS the_answer;") Only the default full-Python integration works. The binary C connector, -provided by _mysql_connector, is not supported. +provided by _mariadb_connector, is not supported. -Help on mysql.connector can be found on: -https://dev.mysql.com/doc/connector-python/en/ +Help on mariadb.connector can be found on: +https://mariadb-corporation.github.io/mariadb-connector-python/usage.html """ from ...utils.importlib import require_modules -# check `mysql-connector` availability +# check `mariadb-connector` availability required_modules = ["mariadb"] with require_modules(required_modules) as missing_modules: diff --git a/docs/index.rst b/docs/index.rst index 66beade5b2d..0556c2bcd32 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -90,6 +90,8 @@ contacting support. +--------------------------------------------------+---------------+----------------+ | :ref:`mako` | >= 0.1.0 | Yes | +--------------------------------------------------+---------------+----------------+ +| :ref:`mariadb` | >= 1.0.0 | Yes | ++--------------------------------------------------+---------------+----------------+ | :ref:`kombu` | >= 4.0 | No | +--------------------------------------------------+---------------+----------------+ | :ref:`molten` | >= 0.7.0 | Yes | diff --git a/docs/integrations.rst b/docs/integrations.rst index 2dad4b3011a..369462b02ca 100644 --- a/docs/integrations.rst +++ b/docs/integrations.rst @@ -191,6 +191,13 @@ Mako .. automodule:: ddtrace.contrib.mako +.. _mariadb: + +Mariadb +^^^^^^^ +.. automodule:: ddtrace.contrib.mariadb + + .. _molten: Molten From 6c0d22a4d30ab15e7f90312f7991168cbe204575 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Thu, 24 Jun 2021 14:47:29 -0600 Subject: [PATCH 12/58] added mariadb to circleci config.yaml --- .circleci/config.yml | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/.circleci/config.yml b/.circleci/config.yml index 3eb6e07564a..a070f17ca7a 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -626,6 +626,14 @@ jobs: pattern: "grpc" snapshot: true + maridb: + <<: *machine_executor + steps: + - run_test: + pattern: 'maridb$' + snapshot: true + docker_services: "mariadb" + molten: <<: *contrib_job steps: @@ -947,6 +955,7 @@ requires_tests: &requires_tests - jinja2 - kombu - mako + - mariadb - molten - mongoengine - mysqlconnector @@ -1028,6 +1037,7 @@ workflows: - jinja2: *requires_base_venvs - kombu: *requires_base_venvs - mako: *requires_base_venvs + - mariadb: *requires_base_venvs - molten: *requires_base_venvs - mongoengine: *requires_base_venvs - mysqlconnector: *requires_base_venvs From 74e945a28fa3958546367024530ba0a177cb039b Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Thu, 24 Jun 2021 15:36:10 -0600 Subject: [PATCH 13/58] added mariadb build steps to dev image --- Dockerfile.buster | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/Dockerfile.buster b/Dockerfile.buster index c507908be4b..81901dc9414 100644 --- a/Dockerfile.buster +++ b/Dockerfile.buster @@ -54,8 +54,13 @@ RUN \ && echo "deb-src https://deb.nodesource.com/${NODE_VERSION} buster main" | tee -a /etc/apt/sources.list.d/nodesource.list \ && apt-get update \ && apt-get install -y --no-install-recommends nodejs \ + && apt-get install -y mariadb-server \ + && curl -sS https://downloads.mariadb.com/MariaDB/mariadb_repo_setup | bash \ + && apt-get install -y libmariadb3 \ # Cleaning up apt cache space - && rm -rf /var/lib/apt/lists/* + && rm -rf /var/lib/apt/lists/* \ + + # Configure PATH environment for pyenv From cb8b2ab1fdad3d31fb6209464c62aabe6a2f8ff0 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Mon, 28 Jun 2021 12:26:50 -0600 Subject: [PATCH 14/58] added malformed query snapshot test --- tests/contrib/mariadb/test_mariadb.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/tests/contrib/mariadb/test_mariadb.py b/tests/contrib/mariadb/test_mariadb.py index 34bbc3acbe7..e99b16cb3d3 100644 --- a/tests/contrib/mariadb/test_mariadb.py +++ b/tests/contrib/mariadb/test_mariadb.py @@ -350,6 +350,13 @@ def test_simple_query_snapshot(tracer): rows = cursor.fetchall() assert len(rows) == 1 +@snapshot(include_tracer=True, ignores=["meta.error.stack"]) +def test_simple_malformed_query_snapshot(tracer): + connection = get_connection(tracer) + cursor = connection.cursor() + with pytest.raises(mariadb.ProgrammingError): + cursor.execute("SELEC 1") + @snapshot(include_tracer=True) def test_simple_query_fetchall( tracer): with override_config("mariadb", dict(trace_fetch_methods=True)): From 158fff0eb36358005afd14eada8e28b6b484ba29 Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Tue, 6 Jul 2021 08:53:43 -0600 Subject: [PATCH 15/58] Fix grammar in mariadb docs Co-authored-by: Brett Langdon --- ddtrace/contrib/mariadb/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ddtrace/contrib/mariadb/__init__.py b/ddtrace/contrib/mariadb/__init__.py index d20038b9d1c..2d24547d67d 100644 --- a/ddtrace/contrib/mariadb/__init__.py +++ b/ddtrace/contrib/mariadb/__init__.py @@ -1,5 +1,5 @@ """ -The integration instruments the mariadb library to trace mariadb queries. +The mariadb integration instruments the mariadb library to trace mariadb queries. Enabling From 5330d3d787e4cf9d0e218f32fe8c53736e4c8481 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Tue, 6 Jul 2021 13:17:08 -0600 Subject: [PATCH 16/58] added mariadb test snapshots, reformatted tests, added guards for patching and unpatching, used black formatter --- ddtrace/__init__.py | 1 - ddtrace/contrib/mariadb/__init__.py | 2 +- ddtrace/contrib/mariadb/patch.py | 30 ++-- docker-compose.yml | 2 +- riotfile.py | 7 +- tests/.DS_Store | Bin 0 -> 8196 bytes .../mariadb/test_backwards_compatibility.py | 14 -- tests/contrib/mariadb/test_mariadb.py | 145 ++++++++---------- tests/contrib/mysql/test_mysql.py | 12 +- ...adb.test_mariadb.test_commit_snapshot.snap | 18 +++ ...test_mariadb.test_query_proc_snapshot.snap | 22 +++ ....test_simple_malformed_query_snapshot.snap | 24 +++ ...b.test_simple_query_fetchall_snapshot.snap | 43 ++++++ ...ice_snapshot_DD_MARIADB_SERVICE_mysvc.snap | 22 +++ ...ied_service_snapshot_DD_SERVICE_mysvc.snap | 22 +++ tests/utils.py | 4 +- 16 files changed, 250 insertions(+), 118 deletions(-) create mode 100644 tests/.DS_Store delete mode 100644 tests/contrib/mariadb/test_backwards_compatibility.py create mode 100644 tests/snapshots/tests.contrib.mariadb.test_mariadb.test_commit_snapshot.snap create mode 100644 tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_proc_snapshot.snap create mode 100644 tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_malformed_query_snapshot.snap create mode 100644 tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_fetchall_snapshot.snap create mode 100644 tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_MARIADB_SERVICE_mysvc.snap create mode 100644 tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_SERVICE_mysvc.snap diff --git a/ddtrace/__init__.py b/ddtrace/__init__.py index c6cff44a38d..f0238cdb39d 100644 --- a/ddtrace/__init__.py +++ b/ddtrace/__init__.py @@ -9,7 +9,6 @@ from .utils.deprecation import deprecated # noqa: E402 - try: __version__ = pkg_resources.get_distribution(__name__).version except pkg_resources.DistributionNotFound: diff --git a/ddtrace/contrib/mariadb/__init__.py b/ddtrace/contrib/mariadb/__init__.py index d20038b9d1c..1360389e177 100644 --- a/ddtrace/contrib/mariadb/__init__.py +++ b/ddtrace/contrib/mariadb/__init__.py @@ -64,5 +64,5 @@ if not missing_modules: from .patch import patch from .patch import unpatch - + __all__ = ["patch", "unpatch"] diff --git a/ddtrace/contrib/mariadb/patch.py b/ddtrace/contrib/mariadb/patch.py index 2ba574ab83c..a9ab183c3ff 100644 --- a/ddtrace/contrib/mariadb/patch.py +++ b/ddtrace/contrib/mariadb/patch.py @@ -3,6 +3,7 @@ from ddtrace import config from ddtrace.contrib.dbapi import TracedConnection from ddtrace.vendor import wrapt +from ddtrace.utils import get_argument_value from ...ext import db from ...ext import net @@ -20,31 +21,34 @@ ) - - def patch(): + if getattr(mariadb, "_datadog_patch", False): + return + setattr(mariadb, "_datadog_patch", True) wrapt.wrap_function_wrapper("mariadb", "connect", _connect) def unpatch(): - if isinstance(mariadb.connect, wrapt.ObjectProxy): - mariadb.connect = mariadb.connect.__wrapped__ - if hasattr(mariadb, "Connect"): - mariadb.Connect = mariadb.connect + if getattr(mariadb, "_datadog_patch", False): + setattr(mariadb, "_datadog_patch", False) + if isinstance(mariadb.connect, wrapt.ObjectProxy): + mariadb.connect = mariadb.connect.__wrapped__ + if hasattr(mariadb, "Connect"): + mariadb.Connect = mariadb.connect def _connect(func, instance, args, kwargs): conn = func(*args, **kwargs) - ##need to pull from args as well at some point - tags = {net.TARGET_HOST: kwargs["host"], - net.TARGET_PORT: kwargs["port"], - db.USER: kwargs["user"], - db.NAME: kwargs["database"], - } + tags = { + net.TARGET_HOST: kwargs["host"], + net.TARGET_PORT: kwargs["port"], + db.USER: kwargs["user"], + db.NAME: kwargs["database"], + } pin = Pin(app="mariadb", tags=tags) # grab the metadata from the conn wrapped = TracedConnection(conn, pin=pin, cfg=config.mariadb) pin.onto(wrapped) - return wrapped \ No newline at end of file + return wrapped diff --git a/docker-compose.yml b/docker-compose.yml index 45058e46dd9..a43bf341726 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -155,4 +155,4 @@ services: volumes: - ddagent: \ No newline at end of file + ddagent: diff --git a/riotfile.py b/riotfile.py index 17aa087a0aa..892039342d3 100644 --- a/riotfile.py +++ b/riotfile.py @@ -918,13 +918,14 @@ def select_pys(min_version=MIN_PYTHON_VERSION, max_version=MAX_PYTHON_VERSION): ), Venv( name="mariadb", - command="python -m pytest {cmdargs} tests/contrib/mariadb", + command="pytest {cmdargs} tests/contrib/mariadb", venvs=[ Venv( pys=select_pys(min_version="3.6"), pkgs={ "mariadb": [ - ">=1.0.0,<1.1.0", + "~=1.0.0", + "~=1.0", latest, ], }, @@ -1019,4 +1020,4 @@ def select_pys(min_version=MIN_PYTHON_VERSION, max_version=MAX_PYTHON_VERSION): command="pytest {cmdargs} tests/contrib/urllib3", ), ], -) \ No newline at end of file +) diff --git a/tests/.DS_Store b/tests/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..0d1367db8b5da4cb7ebe523b3897b5c58c8b673c GIT binary patch literal 8196 zcmeHMOKclO7@p5b+FiPBHld*@WE&H=$SqAUEhwRCk@Ik0Nt8g6#tEgt_HL3@H@mKP z?Sx)16oim^Di0xXr~n}ly#Q*DErL@8CqyJ52oAsjE(H#7C`jUL?A>UL?A@qWn-lfh-Ft+!=&BLohRf3&0D7HB@zpWR8`lkSu4r6ty9)( zhkN__m4URGbL=7Wq%on^y3@|=A?gkmjFM^0j^-SzIAgmLYF#d4<%(9uGdeAc8`D^= zn=3e$HR!meXFB#++B4?7N}wgG^tkI3yly|(gsK)@<57cRnI)r#B2uV&KHET^hjEV> z1(#$jnGnw^pWCphd276NSNq;%YQ9#jtG``oP{vK&usw6qGzw!GH)q(oX-|#Jnz}bV zS~6WTYZ=3KX2y`~uv4C|ZQOk4T}_%M46Zp;Ow+}zd7@}~PpUCV^5=+ZEy_`yR@d+7 zd=_0&FHjtseVf*zJ;pWN1%p~WaM-Ths|>q@jHG6SVVjarhL4-JE~~B>*{wXNjaZqi zVacj4=IK!OXrm?Z$gCH4vX zoPEoFWLMbl><{)Q`wI**YOxu2V+VGk6>Vro4^lXQgLnjw;}|9|jTzX;;{;CPDU|UH zPT@4p;6=QQS8x_@;~l()i*ZWu_?N3$9)ex^l;ZAC2rus z^=$MhC^+VGufi?=YhOa>d4EqRTbe7I;M%qj+hl~OYs^V}2dQg?byIAsM66S#pc~&# z-3w~O?qUxV`Ad5sV^@aU6w#Nld}Sad;@AggK(| zDLjkk@H}4dY5Wq=_*J})H}EFjB09f^_wm6Zoj=0I_!RT_2H)L4-oB;e#rG?dw=`6+ zEytcBZH4wr9m8ITz!C)b-A|>F=l`kI-~anYVG|+{BJlr20M$K1Jzex{tKAzB(nYC0 zL6sM7R~FKDp@y6AaX%d=x%h`6eU1jYWFX5zl7`BE@*+U|j1BL9{~HLKTM>c30bCi! A>;M1& literal 0 HcmV?d00001 diff --git a/tests/contrib/mariadb/test_backwards_compatibility.py b/tests/contrib/mariadb/test_backwards_compatibility.py deleted file mode 100644 index 62e405d3860..00000000000 --- a/tests/contrib/mariadb/test_backwards_compatibility.py +++ /dev/null @@ -1,14 +0,0 @@ -##For Maria DB I don't think this is necesarry, unless Mariadb has an older version that's different. I tested on Mariadb version -## 1.0.6. It looks like https://github.com/mariadb-corporation/mariadb-connector-python/releases?after=v0.9.57 was the first beta release and it doesn't seem to be out of beta yet. -# from ddtrace.contrib.mysql import get_traced_mysql_connection -# from tests.contrib import config -# from tests.utils import DummyTracer - - -# def test_pre_v4(): -# tracer = DummyTracer() -# MySQL = get_traced_mysql_connection(tracer, service="my-mysql-server") -# conn = MySQL(**config.MYSQL_CONFIG) -# cursor = conn.cursor() -# cursor.execute("SELECT 1") -# assert cursor.fetchone()[0] == 1 diff --git a/tests/contrib/mariadb/test_mariadb.py b/tests/contrib/mariadb/test_mariadb.py index e99b16cb3d3..306695b02d5 100644 --- a/tests/contrib/mariadb/test_mariadb.py +++ b/tests/contrib/mariadb/test_mariadb.py @@ -1,5 +1,6 @@ +from logging import ERROR import pytest -import mariadb +import mariadb from tests.utils import DummyTracer from tests.utils import assert_is_measured from tests.utils import assert_dict_issuperset @@ -11,30 +12,24 @@ from ddtrace import tracer as global_tracer from ddtrace.constants import ANALYTICS_SAMPLE_RATE_KEY from tests.utils import snapshot +from tests.contrib.config import MARIADB_CONFIG import unittest - - - - @pytest.fixture def tracer(): tracer = DummyTracer() patch() # Yield to our test - yield tracer - unpatch() + try: + yield tracer + finally: + unpatch() + def get_connection(tracer): - #Some test cases need a connection to be created post-configuration - connection = mariadb.connect( - user="test", - password="test", - host="127.0.0.1", - port=3306, - database="test" - ) + # Some test cases need a connection to be created post-configuration + connection = mariadb.connect(**MARIADB_CONFIG) Pin.override(connection, tracer=tracer) return connection @@ -42,10 +37,8 @@ def get_connection(tracer): @pytest.fixture def connection(tracer): - connection = get_connection(tracer) - - yield connection - connection.close() + with get_connection(tracer) as connection: + yield connection def test_simple_query(connection, tracer): @@ -64,18 +57,20 @@ def test_simple_query(connection, tracer): assert span.get_metric("out.port") == 3306 assert_dict_issuperset( - span.meta, - { - "out.host": u"127.0.0.1", - "db.name": u"test", - "db.user": u"test", - }, - ) + span.meta, + { + "out.host": u"127.0.0.1", + "db.name": u"test", + "db.user": u"test", + }, + ) -def test_simple_query_fetchall( tracer): + +def test_simple_query_fetchall(tracer): with override_config("mariadb", dict(trace_fetch_methods=True)): connection = get_connection(tracer) from ddtrace import config + cursor = connection.cursor() cursor.execute("SELECT 1") rows = cursor.fetchall() @@ -112,6 +107,7 @@ def test_query_with_several_rows(connection, tracer): span = spans[0] assert span.get_tag("mariadb.query") is None + def test_query_with_several_rows_fetchall(tracer): with override_config("mariadb", dict(trace_fetch_methods=True)): connection = get_connection(tracer) @@ -126,6 +122,7 @@ def test_query_with_several_rows_fetchall(tracer): assert span.get_tag("mariadb.query") is None assert spans[1].name == "mariadb.query.fetchall" + def test_query_many(connection, tracer): # tests that the executemany method is correctly wrapped. tracer.enabled = False @@ -160,6 +157,7 @@ def test_query_many(connection, tracer): assert span.get_tag("mariadb.query") is None cursor.execute("drop table if exists dummy") + def test_query_many_fetchall(tracer): with override_config("mariadb", dict(trace_fetch_methods=True)): connection = get_connection(tracer) @@ -199,6 +197,7 @@ def test_query_many_fetchall(tracer): assert spans[2].name == "mariadb.query.fetchall" + def test_query_proc(connection, tracer): # create a procedure @@ -218,7 +217,6 @@ def test_query_proc(connection, tracer): data = (40, 2, None) cursor.callproc(proc, data) - spans = tracer.pop() assert spans, spans @@ -242,6 +240,7 @@ def test_query_proc(connection, tracer): ) assert span.get_tag("mariadb.query") is None + def test_commit(connection, tracer): connection.commit() spans = tracer.pop() @@ -250,6 +249,7 @@ def test_commit(connection, tracer): assert span.service == "mariadb" assert span.name == "mariadb.connection.commit" + def test_rollback(connection, tracer): connection.rollback() spans = tracer.pop() @@ -258,6 +258,7 @@ def test_rollback(connection, tracer): assert span.service == "mariadb" assert span.name == "mariadb.connection.rollback" + def test_analytics_default(connection, tracer): cursor = connection.cursor() cursor.execute("SELECT 1") @@ -268,6 +269,7 @@ def test_analytics_default(connection, tracer): span = spans[0] assert span.get_metric(ANALYTICS_SAMPLE_RATE_KEY) is None + def test_analytics_with_rate(connection, tracer): with override_config("mariadb", dict(analytics_enabled=True, analytics_sample_rate=0.5)): cursor = connection.cursor() @@ -279,6 +281,7 @@ def test_analytics_with_rate(connection, tracer): span = spans[0] assert span.get_metric(ANALYTICS_SAMPLE_RATE_KEY) == 0.5 + def test_analytics_without_rate(connection, tracer): with override_config("mariadb", dict(analytics_enabled=True)): cursor = connection.cursor() @@ -293,55 +296,42 @@ def test_analytics_without_rate(connection, tracer): assert span.get_metric(ANALYTICS_SAMPLE_RATE_KEY) == 1.0 - - -class TestMariadbPatch(TracerTestCase): - def setUp(self): - super(TestMariadbPatch, self).setUp() - patch() - self.connection = mariadb.connect( - user="test", - password="test", - host="127.0.0.1", - port=3306, - database="test" - ) - Pin.override(self.connection, tracer=self.tracer) - - @TracerTestCase.run_in_subprocess(env_overrides=dict(DD_SERVICE="mysvc")) - def test_user_specified_service(self): - """ - When a user specifies a service for the app - The mariadb integration should not use it. +@pytest.mark.parametrize( + "service_env_key,service_env_value", [("DD_SERVICE", "mysvc"), ("DD_MARIADB_SERVICE", "mysvc")] +) +def test_user_specified_service_snapshot(run_python_code_in_subprocess, service_env_key, service_env_value): + """ + When a user specifies a service for the app + The mariadb integration should not use it. + """ + + @snapshot( + async_mode=False, + token_override="tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_{}_{}".format( + service_env_key, service_env_value + ), + ) + def testcase(): + out, err, status, pid = run_python_code_in_subprocess( """ - # Ensure that the service name was configured - from ddtrace import config - - assert config.service == "mysvc" - - cursor = self.connection.cursor() - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 - spans = self.tracer.pop() - - assert spans[0].service != "mysvc" +from ddtrace import config +from ddtrace import patch +import mariadb +patch(mariadb=True) +from tests.contrib.config import MARIADB_CONFIG +connection = mariadb.connect(**MARIADB_CONFIG) +cursor = connection.cursor() +cursor.execute("SELECT 1") +rows = cursor.fetchall() +assert len(rows) == 1 +""", + env={service_env_key: service_env_value}, + ) + assert status == 0, err - def tearDown(self): - super(TestMariadbPatch, self).tearDown() - unpatch() - self.connection.close() + testcase() - @TracerTestCase.run_in_subprocess(env_overrides=dict(DD_MARIADB_SERVICE="mysvc")) - def test_user_specified_service_integration(self): - cursor = self.connection.cursor() - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 - spans = self.tracer.pop() - assert spans[0].service == "mysvc" - @snapshot(include_tracer=True) def test_simple_query_snapshot(tracer): connection = get_connection(tracer) @@ -350,6 +340,7 @@ def test_simple_query_snapshot(tracer): rows = cursor.fetchall() assert len(rows) == 1 + @snapshot(include_tracer=True, ignores=["meta.error.stack"]) def test_simple_malformed_query_snapshot(tracer): connection = get_connection(tracer) @@ -357,8 +348,9 @@ def test_simple_malformed_query_snapshot(tracer): with pytest.raises(mariadb.ProgrammingError): cursor.execute("SELEC 1") + @snapshot(include_tracer=True) -def test_simple_query_fetchall( tracer): +def test_simple_query_fetchall_snapshot(tracer): with override_config("mariadb", dict(trace_fetch_methods=True)): connection = get_connection(tracer) cursor = connection.cursor() @@ -372,8 +364,9 @@ def test_commit_snapshot(tracer): connection = get_connection(tracer) connection.commit() + @snapshot(include_tracer=True) -def test_query_proc(tracer): +def test_query_proc_snapshot(tracer): connection = get_connection(tracer) # create a procedure tracer.enabled = False @@ -391,5 +384,3 @@ def test_query_proc(tracer): proc = "sp_sum" data = (40, 2, None) cursor.callproc(proc, data) - - diff --git a/tests/contrib/mysql/test_mysql.py b/tests/contrib/mysql/test_mysql.py index d80b3654482..4c5be249505 100644 --- a/tests/contrib/mysql/test_mysql.py +++ b/tests/contrib/mysql/test_mysql.py @@ -59,7 +59,7 @@ def test_simple_query(self): ) def test_simple_query_fetchall(self): - with self.override_config("dbapi2", dict(trace_fetch_methods=True)): + with self.override_config("mysql", dict(trace_fetch_methods=True)): conn, tracer = self._get_conn_tracer() cursor = conn.cursor() cursor.execute("SELECT 1") @@ -99,7 +99,7 @@ def test_query_with_several_rows(self): assert span.get_tag("sql.query") is None def test_query_with_several_rows_fetchall(self): - with self.override_config("dbapi2", dict(trace_fetch_methods=True)): + with self.override_config("mysql", dict(trace_fetch_methods=True)): conn, tracer = self._get_conn_tracer() cursor = conn.cursor() query = "SELECT n FROM (SELECT 42 n UNION SELECT 421 UNION SELECT 4210) m" @@ -148,7 +148,7 @@ def test_query_many(self): cursor.execute("drop table if exists dummy") def test_query_many_fetchall(self): - with self.override_config("dbapi2", dict(trace_fetch_methods=True)): + with self.override_config("mysql", dict(trace_fetch_methods=True)): # tests that the executemany method is correctly wrapped. conn, tracer = self._get_conn_tracer() tracer.enabled = False @@ -271,7 +271,7 @@ def test_simple_query_ot(self): def test_simple_query_ot_fetchall(self): """OpenTracing version of test_simple_query.""" - with self.override_config("dbapi2", dict(trace_fetch_methods=True)): + with self.override_config("mysql", dict(trace_fetch_methods=True)): conn, tracer = self._get_conn_tracer() ot_tracer = init_tracer("mysql_svc", tracer) @@ -342,7 +342,7 @@ def test_analytics_default(self): self.assertIsNone(span.get_metric(ANALYTICS_SAMPLE_RATE_KEY)) def test_analytics_with_rate(self): - with self.override_config("dbapi2", dict(analytics_enabled=True, analytics_sample_rate=0.5)): + with self.override_config("mysql", dict(analytics_enabled=True, analytics_sample_rate=0.5)): conn, tracer = self._get_conn_tracer() cursor = conn.cursor() cursor.execute("SELECT 1") @@ -355,7 +355,7 @@ def test_analytics_with_rate(self): self.assertEqual(span.get_metric(ANALYTICS_SAMPLE_RATE_KEY), 0.5) def test_analytics_without_rate(self): - with self.override_config("dbapi2", dict(analytics_enabled=True)): + with self.override_config("mysql", dict(analytics_enabled=True)): conn, tracer = self._get_conn_tracer() cursor = conn.cursor() cursor.execute("SELECT 1") diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_commit_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_commit_snapshot.snap new file mode 100644 index 00000000000..5ebd6ba1953 --- /dev/null +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_commit_snapshot.snap @@ -0,0 +1,18 @@ +[[{"name" "mariadb.connection.commit" + "service" "mariadb" + "resource" "mariadb.connection.commit" + "error" 0 + "span_id" 0 + "trace_id" 0 + "parent_id" nil + "start" 1625591312382107800 + "duration" 721500 + "meta" {"runtime-id" "782d3f7fec4e4e2386c600eac7a84772" + "out.host" "127.0.0.1" + "db.user" "test" + "db.name" "test"} + "metrics" {"_dd.agent_psr" 1.0 + "_sampling_priority_v1" 1 + "system.pid" 2783 + "out.port" 3306 + "_dd.tracer_kr" 1.0}}]] diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_proc_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_proc_snapshot.snap new file mode 100644 index 00000000000..1024546a31c --- /dev/null +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_proc_snapshot.snap @@ -0,0 +1,22 @@ +[[{"name" "mariadb.query" + "service" "mariadb" + "resource" "sp_sum" + "type" "sql" + "error" 0 + "span_id" 0 + "trace_id" 0 + "parent_id" nil + "start" 1625591312426440800 + "duration" 674500 + "meta" {"runtime-id" "782d3f7fec4e4e2386c600eac7a84772" + "out.host" "127.0.0.1" + "db.user" "test" + "db.name" "test"} + "metrics" {"_dd.agent_psr" 1.0 + "_dd.measured" 1 + "_sampling_priority_v1" 1 + "system.pid" 2783 + "out.port" 3306 + "db.rowcount" 0 + "sql.rows" 0 + "_dd.tracer_kr" 1.0}}]] diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_malformed_query_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_malformed_query_snapshot.snap new file mode 100644 index 00000000000..a5c5189d44d --- /dev/null +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_malformed_query_snapshot.snap @@ -0,0 +1,24 @@ +[[{"name" "mariadb.query" + "service" "mariadb" + "resource" "SELEC 1" + "type" "sql" + "error" 1 + "span_id" 0 + "trace_id" 0 + "parent_id" nil + "start" 1625591312281637200 + "duration" 3629000 + "meta" {"runtime-id" "782d3f7fec4e4e2386c600eac7a84772" + "out.host" "127.0.0.1" + "db.user" "test" + "db.name" "test" + "error.msg" "You have an error in your SQL syntax; check the manual that corresponds to your MariaDB server version for the right syntax to use near 'SELEC 1' at line 1" + "error.type" "mariadb.ProgrammingError" + "error.stack" "Traceback (most recent call last):\n File \"/root/project/ddtrace/contrib/dbapi/__init__.py\", line 73, in _trace_method\n return method(*args, **kwargs)\nmariadb.ProgrammingError: You have an error in your SQL syntax; check the manual that corresponds to your MariaDB server version for the right syntax to use near 'SELEC 1' at line 1\n"} + "metrics" {"_dd.agent_psr" 1.0 + "_dd.measured" 1 + "_sampling_priority_v1" 1 + "system.pid" 2783 + "out.port" 3306 + "db.rowcount" -1 + "_dd.tracer_kr" 1.0}}]] diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_fetchall_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_fetchall_snapshot.snap new file mode 100644 index 00000000000..28ed902d1e2 --- /dev/null +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_fetchall_snapshot.snap @@ -0,0 +1,43 @@ +[[{"name" "mariadb.query" + "service" "mariadb" + "resource" "SELECT 1" + "type" "sql" + "error" 0 + "span_id" 0 + "trace_id" 0 + "parent_id" nil + "start" 1625591312342722800 + "duration" 652100 + "meta" {"runtime-id" "782d3f7fec4e4e2386c600eac7a84772" + "out.host" "127.0.0.1" + "db.user" "test" + "db.name" "test"} + "metrics" {"_dd.agent_psr" 1.0 + "_dd.measured" 1 + "_sampling_priority_v1" 1 + "system.pid" 2783 + "out.port" 3306 + "db.rowcount" 0 + "sql.rows" 0 + "_dd.tracer_kr" 1.0}}] + [{"name" "mariadb.query.fetchall" + "service" "mariadb" + "resource" "SELECT 1" + "type" "sql" + "error" 0 + "span_id" 0 + "trace_id" 1 + "parent_id" nil + "start" 1625591312343788700 + "duration" 70700 + "meta" {"runtime-id" "782d3f7fec4e4e2386c600eac7a84772" + "out.host" "127.0.0.1" + "db.user" "test" + "db.name" "test"} + "metrics" {"_dd.agent_psr" 1.0 + "_sampling_priority_v1" 1 + "system.pid" 2783 + "out.port" 3306 + "db.rowcount" 1 + "sql.rows" 1 + "_dd.tracer_kr" 1.0}}]] diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_MARIADB_SERVICE_mysvc.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_MARIADB_SERVICE_mysvc.snap new file mode 100644 index 00000000000..83252d30eef --- /dev/null +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_MARIADB_SERVICE_mysvc.snap @@ -0,0 +1,22 @@ +[[{"name" "mariadb.query" + "service" "mysvc" + "resource" "SELECT 1" + "type" "sql" + "error" 0 + "span_id" 0 + "trace_id" 0 + "parent_id" nil + "start" 1625596683600375000 + "duration" 690600 + "meta" {"runtime-id" "eab9e81e7dec488986d9f545801583eb" + "out.host" "127.0.0.1" + "db.user" "test" + "db.name" "test"} + "metrics" {"_dd.agent_psr" 1.0 + "_dd.measured" 1 + "_sampling_priority_v1" 1 + "system.pid" 5449 + "out.port" 3306 + "db.rowcount" 0 + "sql.rows" 0 + "_dd.tracer_kr" 1.0}}]] diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_SERVICE_mysvc.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_SERVICE_mysvc.snap new file mode 100644 index 00000000000..4d7b9e30f2a --- /dev/null +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_SERVICE_mysvc.snap @@ -0,0 +1,22 @@ +[[{"name" "mariadb.query" + "service" "mariadb" + "resource" "SELECT 1" + "type" "sql" + "error" 0 + "span_id" 0 + "trace_id" 0 + "parent_id" nil + "start" 1625596682648238100 + "duration" 958400 + "meta" {"runtime-id" "89a1db1d235b41fd8fb8d6878e423840" + "out.host" "127.0.0.1" + "db.user" "test" + "db.name" "test"} + "metrics" {"_dd.agent_psr" 1.0 + "_dd.measured" 1 + "_sampling_priority_v1" 1 + "system.pid" 5446 + "out.port" 3306 + "db.rowcount" 0 + "sql.rows" 0 + "_dd.tracer_kr" 1.0}}]] diff --git a/tests/utils.py b/tests/utils.py index 8b85193c474..9f4adb2ee29 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -880,7 +880,7 @@ def snapshot_context(token, ignores=None, tracer=None, async_mode=True): conn.close() -def snapshot(ignores=None, include_tracer=False, variants=None, async_mode=True): +def snapshot(ignores=None, include_tracer=False, variants=None, async_mode=True, token_override=None): """Performs a snapshot integration test with the testing agent. All traces sent to the agent will be recorded and compared to a snapshot @@ -910,7 +910,7 @@ def wrapper(wrapped, instance, args, kwargs): # Use the fully qualified function name as a unique test token to # identify the snapshot. - token = "{}{}{}.{}".format(module.__name__, "." if clsname else "", clsname, wrapped.__name__) + token = token_override or "{}{}{}.{}".format(module.__name__, "." if clsname else "", clsname, wrapped.__name__) # Use variant that applies to update test token. One must apply. If none # apply, the test should have been marked as skipped. From 1f2974285683a6741ad72c765ddddf7f4e43da8b Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Tue, 13 Jul 2021 01:36:33 +0800 Subject: [PATCH 17/58] added release notes --- releasenotes/notes/mariadb-8e7bc94a0d1b8f02.yaml | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 releasenotes/notes/mariadb-8e7bc94a0d1b8f02.yaml diff --git a/releasenotes/notes/mariadb-8e7bc94a0d1b8f02.yaml b/releasenotes/notes/mariadb-8e7bc94a0d1b8f02.yaml new file mode 100644 index 00000000000..a0babfde6c1 --- /dev/null +++ b/releasenotes/notes/mariadb-8e7bc94a0d1b8f02.yaml @@ -0,0 +1,4 @@ +--- +features: + - | + Add MariaDB integration. \ No newline at end of file From 2b8683a6746e969b7d03e4d43e0006bbd2a053b7 Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Tue, 13 Jul 2021 15:37:46 -0600 Subject: [PATCH 18/58] add link to library this instruments Co-authored-by: Kyle Verhoog --- ddtrace/contrib/mariadb/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ddtrace/contrib/mariadb/__init__.py b/ddtrace/contrib/mariadb/__init__.py index 82890845b61..52aa6dcba0f 100644 --- a/ddtrace/contrib/mariadb/__init__.py +++ b/ddtrace/contrib/mariadb/__init__.py @@ -1,5 +1,5 @@ """ -The mariadb integration instruments the mariadb library to trace mariadb queries. +The MariaDB integration instruments the :ref:`MariaDB library` to trace queries. Enabling From 8d3e56b51725530a2a1666c7e84c9f4907f621fa Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Tue, 13 Jul 2021 15:38:10 -0600 Subject: [PATCH 19/58] remove comment Co-authored-by: Kyle Verhoog --- ddtrace/contrib/mariadb/__init__.py | 1 - 1 file changed, 1 deletion(-) diff --git a/ddtrace/contrib/mariadb/__init__.py b/ddtrace/contrib/mariadb/__init__.py index 52aa6dcba0f..b6d12077517 100644 --- a/ddtrace/contrib/mariadb/__init__.py +++ b/ddtrace/contrib/mariadb/__init__.py @@ -57,7 +57,6 @@ from ...utils.importlib import require_modules -# check `mariadb-connector` availability required_modules = ["mariadb"] with require_modules(required_modules) as missing_modules: From eac06e3d8dc40f320214644a0ec975b3c3d2af4a Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Tue, 13 Jul 2021 15:41:02 -0600 Subject: [PATCH 20/58] Update ddtrace/contrib/mariadb/__init__.py Co-authored-by: Kyle Verhoog --- ddtrace/contrib/mariadb/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ddtrace/contrib/mariadb/__init__.py b/ddtrace/contrib/mariadb/__init__.py index b6d12077517..012f2cbc354 100644 --- a/ddtrace/contrib/mariadb/__init__.py +++ b/ddtrace/contrib/mariadb/__init__.py @@ -5,7 +5,7 @@ Enabling ~~~~~~~~ -The mariadb integration is enabled automatically when using +The MariaDB integration is enabled automatically when using :ref:`ddtrace-run` or :ref:`patch_all()`. Or use :ref:`patch()` to manually enable the integration:: From 489eddb6babe108d77681c32c49d4e0bbe931b96 Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Tue, 13 Jul 2021 15:41:11 -0600 Subject: [PATCH 21/58] Update ddtrace/contrib/mariadb/__init__.py Co-authored-by: Kyle Verhoog --- ddtrace/contrib/mariadb/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ddtrace/contrib/mariadb/__init__.py b/ddtrace/contrib/mariadb/__init__.py index 012f2cbc354..1906389be64 100644 --- a/ddtrace/contrib/mariadb/__init__.py +++ b/ddtrace/contrib/mariadb/__init__.py @@ -19,7 +19,7 @@ .. py:data:: ddtrace.config.mariadb["service"] - The service name reported by default for mariadb spans. + The service name reported by default for MariaDB spans. This option can also be set with the ``DD_MARIADB_SERVICE`` environment variable. From b7cb45e8ed0474b8486c44d1307d57d748b53ed9 Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Tue, 13 Jul 2021 16:17:39 -0600 Subject: [PATCH 22/58] Update ddtrace/contrib/mariadb/patch.py Co-authored-by: Kyle Verhoog --- ddtrace/contrib/mariadb/patch.py | 1 - 1 file changed, 1 deletion(-) diff --git a/ddtrace/contrib/mariadb/patch.py b/ddtrace/contrib/mariadb/patch.py index a9ab183c3ff..0c12c80bdc9 100644 --- a/ddtrace/contrib/mariadb/patch.py +++ b/ddtrace/contrib/mariadb/patch.py @@ -48,7 +48,6 @@ def _connect(func, instance, args, kwargs): pin = Pin(app="mariadb", tags=tags) - # grab the metadata from the conn wrapped = TracedConnection(conn, pin=pin, cfg=config.mariadb) pin.onto(wrapped) return wrapped From 123d41b5d0b02978c9173d55c1650d4683bf6765 Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Tue, 13 Jul 2021 16:18:12 -0600 Subject: [PATCH 23/58] Update docs/integrations.rst Co-authored-by: Kyle Verhoog --- docs/integrations.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/integrations.rst b/docs/integrations.rst index 0035d2a8b37..bba4686ed84 100644 --- a/docs/integrations.rst +++ b/docs/integrations.rst @@ -195,7 +195,7 @@ Mako .. _mariadb: -Mariadb +MariaDB ^^^^^^^ .. automodule:: ddtrace.contrib.mariadb From ceb192317b2ee5dd5378a69d618dcce743a21af9 Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Tue, 13 Jul 2021 16:18:35 -0600 Subject: [PATCH 24/58] Update releasenotes/notes/mariadb-8e7bc94a0d1b8f02.yaml Co-authored-by: Kyle Verhoog --- releasenotes/notes/mariadb-8e7bc94a0d1b8f02.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/releasenotes/notes/mariadb-8e7bc94a0d1b8f02.yaml b/releasenotes/notes/mariadb-8e7bc94a0d1b8f02.yaml index a0babfde6c1..4b159551642 100644 --- a/releasenotes/notes/mariadb-8e7bc94a0d1b8f02.yaml +++ b/releasenotes/notes/mariadb-8e7bc94a0d1b8f02.yaml @@ -1,4 +1,4 @@ --- features: - | - Add MariaDB integration. \ No newline at end of file + Add MariaDB integration. From e6c0759303680dbd77f1a16117ef7a10e7c587be Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Tue, 13 Jul 2021 16:27:45 -0600 Subject: [PATCH 25/58] edits to comments --- ddtrace/contrib/mariadb/__init__.py | 11 +++++------ ddtrace/contrib/mariadb/patch.py | 6 ++---- tests/.DS_Store | Bin 8196 -> 0 bytes tests/contrib/mariadb/test_mariadb.py | 1 + tests/contrib/mysql/test_mysql.py | 2 +- 5 files changed, 9 insertions(+), 11 deletions(-) delete mode 100644 tests/.DS_Store diff --git a/ddtrace/contrib/mariadb/__init__.py b/ddtrace/contrib/mariadb/__init__.py index 82890845b61..94049cc4f5f 100644 --- a/ddtrace/contrib/mariadb/__init__.py +++ b/ddtrace/contrib/mariadb/__init__.py @@ -34,8 +34,11 @@ ``Pin`` API:: from ddtrace import Pin - # Make sure to import mariadb.connector and not the 'connect' function, - # otherwise you won't have access to the patched version + from ddtrace import patch + + # Make sure to patch before importing mariadb + patch(mariadb=True) + import mariadb.connector # This will report a span with the default settings @@ -47,10 +50,6 @@ cursor = conn.cursor() cursor.execute("SELECT 6*7 AS the_answer;") - -Only the default full-Python integration works. The binary C connector, -provided by _mariadb_connector, is not supported. - Help on mariadb.connector can be found on: https://mariadb-corporation.github.io/mariadb-connector-python/usage.html """ diff --git a/ddtrace/contrib/mariadb/patch.py b/ddtrace/contrib/mariadb/patch.py index a9ab183c3ff..913b5a952e6 100644 --- a/ddtrace/contrib/mariadb/patch.py +++ b/ddtrace/contrib/mariadb/patch.py @@ -10,6 +10,7 @@ from ...utils.formats import asbool from ...utils.formats import get_env +from ...utils.wrappers import unwrap config._add( @@ -31,10 +32,7 @@ def patch(): def unpatch(): if getattr(mariadb, "_datadog_patch", False): setattr(mariadb, "_datadog_patch", False) - if isinstance(mariadb.connect, wrapt.ObjectProxy): - mariadb.connect = mariadb.connect.__wrapped__ - if hasattr(mariadb, "Connect"): - mariadb.Connect = mariadb.connect + unwrap(mariadb, "connect") def _connect(func, instance, args, kwargs): diff --git a/tests/.DS_Store b/tests/.DS_Store deleted file mode 100644 index 0d1367db8b5da4cb7ebe523b3897b5c58c8b673c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8196 zcmeHMOKclO7@p5b+FiPBHld*@WE&H=$SqAUEhwRCk@Ik0Nt8g6#tEgt_HL3@H@mKP z?Sx)16oim^Di0xXr~n}ly#Q*DErL@8CqyJ52oAsjE(H#7C`jUL?A>UL?A@qWn-lfh-Ft+!=&BLohRf3&0D7HB@zpWR8`lkSu4r6ty9)( zhkN__m4URGbL=7Wq%on^y3@|=A?gkmjFM^0j^-SzIAgmLYF#d4<%(9uGdeAc8`D^= zn=3e$HR!meXFB#++B4?7N}wgG^tkI3yly|(gsK)@<57cRnI)r#B2uV&KHET^hjEV> z1(#$jnGnw^pWCphd276NSNq;%YQ9#jtG``oP{vK&usw6qGzw!GH)q(oX-|#Jnz}bV zS~6WTYZ=3KX2y`~uv4C|ZQOk4T}_%M46Zp;Ow+}zd7@}~PpUCV^5=+ZEy_`yR@d+7 zd=_0&FHjtseVf*zJ;pWN1%p~WaM-Ths|>q@jHG6SVVjarhL4-JE~~B>*{wXNjaZqi zVacj4=IK!OXrm?Z$gCH4vX zoPEoFWLMbl><{)Q`wI**YOxu2V+VGk6>Vro4^lXQgLnjw;}|9|jTzX;;{;CPDU|UH zPT@4p;6=QQS8x_@;~l()i*ZWu_?N3$9)ex^l;ZAC2rus z^=$MhC^+VGufi?=YhOa>d4EqRTbe7I;M%qj+hl~OYs^V}2dQg?byIAsM66S#pc~&# z-3w~O?qUxV`Ad5sV^@aU6w#Nld}Sad;@AggK(| zDLjkk@H}4dY5Wq=_*J})H}EFjB09f^_wm6Zoj=0I_!RT_2H)L4-oB;e#rG?dw=`6+ zEytcBZH4wr9m8ITz!C)b-A|>F=l`kI-~anYVG|+{BJlr20M$K1Jzex{tKAzB(nYC0 zL6sM7R~FKDp@y6AaX%d=x%h`6eU1jYWFX5zl7`BE@*+U|j1BL9{~HLKTM>c30bCi! A>;M1& diff --git a/tests/contrib/mariadb/test_mariadb.py b/tests/contrib/mariadb/test_mariadb.py index 306695b02d5..e923c447ba1 100644 --- a/tests/contrib/mariadb/test_mariadb.py +++ b/tests/contrib/mariadb/test_mariadb.py @@ -16,6 +16,7 @@ import unittest + @pytest.fixture def tracer(): tracer = DummyTracer() diff --git a/tests/contrib/mysql/test_mysql.py b/tests/contrib/mysql/test_mysql.py index 4c5be249505..4a536311fbc 100644 --- a/tests/contrib/mysql/test_mysql.py +++ b/tests/contrib/mysql/test_mysql.py @@ -58,7 +58,7 @@ def test_simple_query(self): }, ) - def test_simple_query_fetchall(self): + def test_simple_query_fetchll(self): with self.override_config("mysql", dict(trace_fetch_methods=True)): conn, tracer = self._get_conn_tracer() cursor = conn.cursor() From 68c82d5634399e0c8b1d85f5f600990b235d936a Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Tue, 13 Jul 2021 17:47:15 -0600 Subject: [PATCH 26/58] Update tests/contrib/mariadb/test_mariadb.py Co-authored-by: Kyle Verhoog --- tests/contrib/mariadb/test_mariadb.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/contrib/mariadb/test_mariadb.py b/tests/contrib/mariadb/test_mariadb.py index 306695b02d5..5cba8ad86be 100644 --- a/tests/contrib/mariadb/test_mariadb.py +++ b/tests/contrib/mariadb/test_mariadb.py @@ -20,7 +20,6 @@ def tracer(): tracer = DummyTracer() patch() - # Yield to our test try: yield tracer finally: From 8626c457a8cb8baf5c7860b2bb27e55743641420 Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Tue, 13 Jul 2021 17:48:17 -0600 Subject: [PATCH 27/58] Update tests/contrib/mariadb/test_mariadb.py Co-authored-by: Kyle Verhoog --- tests/contrib/mariadb/test_mariadb.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/contrib/mariadb/test_mariadb.py b/tests/contrib/mariadb/test_mariadb.py index 5cba8ad86be..e5bd105ef8c 100644 --- a/tests/contrib/mariadb/test_mariadb.py +++ b/tests/contrib/mariadb/test_mariadb.py @@ -27,7 +27,6 @@ def tracer(): def get_connection(tracer): - # Some test cases need a connection to be created post-configuration connection = mariadb.connect(**MARIADB_CONFIG) Pin.override(connection, tracer=tracer) From faad6ebd654e6c8d8202997d87b102bbb83fa31b Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Tue, 13 Jul 2021 17:48:53 -0600 Subject: [PATCH 28/58] Update tests/contrib/mariadb/test_mariadb.py Co-authored-by: Kyle Verhoog --- tests/contrib/mariadb/test_mariadb.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/contrib/mariadb/test_mariadb.py b/tests/contrib/mariadb/test_mariadb.py index e5bd105ef8c..89087ad3c1b 100644 --- a/tests/contrib/mariadb/test_mariadb.py +++ b/tests/contrib/mariadb/test_mariadb.py @@ -221,7 +221,7 @@ def test_query_proc(connection, tracer): # number of spans depends on mariadb implementation details, # typically, internal calls to execute, but at least we # can expect the last closed span to be our proc. - span = spans[len(spans) - 1] + span = spans[-1] assert_is_measured(span) assert span.service == "mariadb" assert span.name == "mariadb.query" From 8ecb7822db5e4fa0873cb5220573a96aab736c8b Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Tue, 13 Jul 2021 21:36:48 -0600 Subject: [PATCH 29/58] switched tests to snapshots and other small changes --- .DS_Store | Bin 0 -> 8196 bytes ddtrace/contrib/mariadb/__init__.py | 2 +- tests/.DS_Store | Bin 0 -> 10244 bytes tests/contrib/config.py | 8 +- tests/contrib/mariadb/test_mariadb.py | 246 +++++------------- tests/runtime/.DS_Store | Bin 0 -> 6148 bytes tests/snapshots/.DS_Store | Bin 0 -> 6148 bytes ...adb.test_analytics_with_rate_snapshot.snap | 23 ++ ....test_analytics_without_rate_snapshot.snap | 23 ++ ...adb.test_mariadb.test_commit_snapshot.snap | 8 +- ...adb.test_query_many_fetchall_snapshot.snap | 66 +++++ ...test_mariadb.test_query_proc_snapshot.snap | 8 +- ...y_with_several_rows_fetchall_snapshot.snap | 43 +++ ...test_query_with_several_rows_snapshot.snap | 22 ++ ....test_simple_malformed_query_snapshot.snap | 8 +- ...b.test_simple_query_fetchall_snapshot.snap | 16 +- ...st_mariadb.test_simple_query_snapshot.snap | 8 +- ...ice_snapshot_DD_MARIADB_SERVICE_mysvc.snap | 8 +- ...ied_service_snapshot_DD_SERVICE_mysvc.snap | 8 +- 19 files changed, 284 insertions(+), 213 deletions(-) create mode 100644 .DS_Store create mode 100644 tests/.DS_Store create mode 100644 tests/runtime/.DS_Store create mode 100644 tests/snapshots/.DS_Store create mode 100644 tests/snapshots/tests.contrib.mariadb.test_mariadb.test_analytics_with_rate_snapshot.snap create mode 100644 tests/snapshots/tests.contrib.mariadb.test_mariadb.test_analytics_without_rate_snapshot.snap create mode 100644 tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_many_fetchall_snapshot.snap create mode 100644 tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_with_several_rows_fetchall_snapshot.snap create mode 100644 tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_with_several_rows_snapshot.snap diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..ee870c78688c4a7bcf083ef502bc68074c7e8ad3 GIT binary patch literal 8196 zcmeHMTWl3Y7@qI6z;3&=3shT&f|m4RDORODy@*zdtvxMmDRR2!>Luj>?AYa?ELf3 zKl9HwJLliS7(-W1Z(^*9F(y&wsFqT3mBi&dFG-Q0rI-+;&zPH@cBj&olU~v{YzRFN zdLZ;b=z-7!p$D!H573>>leEmeFQj1^dLZ<`4e0^?euz`%maag0xSshRcTBSJs?m;5Mn^6lRVD56D9&I2o&lJLY*P7j37dRZ=Lkwes_k1 zz_1KG5PD##2l(+>!8~R#m&*C^`}y>gWx8Ht<3&V@idU>$B}pYEC96vwO&)Znlb+_~ z+%7FU&YuP}?_fHp4>^u?rLLv-n8tKUt>|`aPcv;J>noeOL0$HZn6~arcR4v*cl~ja zLLf=9ET`1tYcXNj%)H^#zsBk zu*YRfM5B9MC+l_lgQZk8=Nf|sjb-MI9vaadHOVAbR3V=(tBh@|y`!O}ZAaIIa&^tx zbrp)Tm%L|t=3}Oj9iBFI@8Fo`W(-?5?E@ou(>2qUF=T6##v0VivaeOOJ{ld(rOn54 zrgucGktDyhdP7v%r<2Luj?PEZ)w7c5ziC4>I?g5CS%XSFP`JG=stmb&W?Ink&U!@| zIz-#6x`C<2CM7y-X=%e!by?Wi)~ZBD^1`d?uAuRr3MD$4aV95eDQ?i#-Vu%N=Vtpf z*Xy4$Y?{)?f$eUZ(ioR@>N=m0RFg;){Qa*G)Yx{ME}fiAM2AH%>KcW<9Kr zO|UGRVJFxN>@+*W&at=HhwM{!k$uB{U_Y_n*zfEQ_9r4J#cGtH995`A9X4YNn$eC9 zB+!e8F@Q%fh;d9HjSO^5!bJ{wOrwA&@f4oMGk6v+;}yJ$H}N*!#d~-kAK^26jxX>f zzQ*_X5x?M9F~7(hpLYlI4FG>rW!{-3J_q02BB!p-=h#jnw6g2^<@2R7LE@Wku8h}i z+1kAQzRoKoShVvCm^q(}J_7~CeCo|n%ir}2MD<%@)yl1NCt>jk878tChb4YC)K#MQ zrr2!~@l2KcN2M-SD$_|2vbtEkB&iW0X^1t+M18eL$Xb+EiAb)l5Yjf~UYU-8S}dgP zNet8>pG(9Mxtp0+I*UJqX#?DPgEU562sV! z6f~miAy`CL2ZwP4GdPChcp{+e2|S1A@gh#*CA@~$@di=%G|u2G&Jl&*!3X#R7jOxe z7m>Da5oy0$NZNcdYg>+efLiBhzEB~2y5=4z5*Dg>{D1%Q-~X@qJVFDZ2SN}0e;z<_ zPqL?r>@W8w=CO91@&sj`c)x-`Uxf-k94GX{al$Kq7*ah>UAayoz=A+(q4b}B2oS%7 O!}~wH|9$@5sKq}!a2G`Y literal 0 HcmV?d00001 diff --git a/ddtrace/contrib/mariadb/__init__.py b/ddtrace/contrib/mariadb/__init__.py index 94049cc4f5f..de89ffdb26a 100644 --- a/ddtrace/contrib/mariadb/__init__.py +++ b/ddtrace/contrib/mariadb/__init__.py @@ -38,7 +38,7 @@ # Make sure to patch before importing mariadb patch(mariadb=True) - + import mariadb.connector # This will report a span with the default settings diff --git a/tests/.DS_Store b/tests/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..1f1d4a3fff6e5c568b05145c2c8139d6f7c7c07c GIT binary patch literal 10244 zcmeI1dvF!i9mmi2^4bjxSuhA(@4_Vk2^t_Igb)F+vFc2#W(K8W|FE5D`$x6aKGm7_ch1?p~MIld{D{ziA&J+QfaE@a>qiqAB$$cMtHJ!rx**HmCA9uTD1M+c9Zna|YR* z!GAOS9SX$Tsa;%DXGlmJK0^O_9yW7WmgQK6c@y{VPKru?l^U`w*Q>5Ri^z?ZpZCzEowyy3(ReZF*zPc*Dv3Apm z6RNU!)rPG*`Ua03AHDg+$$RC<;Li@Mv}mOFO&+H04mYQ4KFr8?FwAqoFx8T|+C1a> zw)UOct{$u3$#h!B&0f9KrIGHSWJlH+RTXsQcPrH+>_SsJ}8W*D-<`36DNo?ObhDQ9`d^a@20?}!`a+QBq^ z-A*UX-;!4J)6@^WeU(ve9N;C*S(Bb=zrh;gO0CN!&nS9QR$Ql5Yh6c30IKfFoLa5U z*kdPCrmgB}`JT<%7NdJu4q4UPWad_Fke`>|YuDx!@^;+w+SNxmvh0MzqUAj2F z>WcLn8@4s&;n?+EX>0~EJr1(u>}ci7ou&$PV7ZDdaxe{ zVd4-D!@?1G$YB^qNy4|_tN0qej&BMHe}^P|4<5q9cm&@kDgOkI;qknbU%=1tGRE;1 z-Yybud!cag`^mx`?#yOvCv%uexZG9d60MSKi0l9brpH`)<}8@?QXuUK%qsb;n57c4 zmX40DZK&B)6|Za9d{Jm|DA9F6Xx&eRQ;c;2xXuJ)Ed*CogmL?n*!bKamY-B~aAL() zh``<2B#Bj~O(fQZFeCz%154t9f;2jrOvbWkA(`~kimYG0EE=6SANXXte05ZkNl*F} zudLD}nFvg>Y4rvzDrXKo?E|N7lNJqT5WUUM+)}1R^HY(Zx9yr}v}jf$FiC1P(@ zDRHuotAd>;lStA-k}1!95#Keeg|)LjTEUI7+u1$r6anfCdy@Tvy~572x7Z)qyX^1m zU+mxPKZsy1Mf!Zg)Do=1YKr$YsKGW|LovStUqA8o$A-cuipHFL)2{%MZ?@X=gA1Y4H)+sdfEvc-l_F z*4n18t_!%dhOfvP^I|AcKml$hit?h6l6Ww*JeP_i#pe=_k$_9(v6Xxw`$*v%|u1ABAYcs8_wqqAbb~ie)N35=rB-?FGfono zq;zj5Jl&0ZaUZ@*c=`dYv>p{Jt z`AuH1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3 zem<@ulZcFPQ@L2!n>{z**++&mCkOWA81W14cNZlEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ zLs35+`xjp>T0H1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3 zem<@ulZcFPQ@L2!n>{z**++&mCkOWA81W14cNZlEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ zLs35+`xjp>T0 Date: Tue, 13 Jul 2021 21:39:12 -0600 Subject: [PATCH 30/58] getting rid of .DS_Stores --- .gitignore | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.gitignore b/.gitignore index 66e602f510b..159b592e0bc 100644 --- a/.gitignore +++ b/.gitignore @@ -106,3 +106,6 @@ ENV/ # VS Code .vscode/ + +#Mac stuff +.DS_Store From 26761439a1ea19e43bd66e97123d0cc989da82a3 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Tue, 13 Jul 2021 21:40:55 -0600 Subject: [PATCH 31/58] getting rid of DS_Store --- .DS_Store | Bin 8196 -> 0 bytes tests/.DS_Store | Bin 10244 -> 0 bytes tests/runtime/.DS_Store | Bin 6148 -> 0 bytes tests/snapshots/.DS_Store | Bin 6148 -> 0 bytes 4 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 .DS_Store delete mode 100644 tests/.DS_Store delete mode 100644 tests/runtime/.DS_Store delete mode 100644 tests/snapshots/.DS_Store diff --git a/.DS_Store b/.DS_Store deleted file mode 100644 index ee870c78688c4a7bcf083ef502bc68074c7e8ad3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8196 zcmeHMTWl3Y7@qI6z;3&=3shT&f|m4RDORODy@*zdtvxMmDRR2!>Luj>?AYa?ELf3 zKl9HwJLliS7(-W1Z(^*9F(y&wsFqT3mBi&dFG-Q0rI-+;&zPH@cBj&olU~v{YzRFN zdLZ;b=z-7!p$D!H573>>leEmeFQj1^dLZ<`4e0^?euz`%maag0xSshRcTBSJs?m;5Mn^6lRVD56D9&I2o&lJLY*P7j37dRZ=Lkwes_k1 zz_1KG5PD##2l(+>!8~R#m&*C^`}y>gWx8Ht<3&V@idU>$B}pYEC96vwO&)Znlb+_~ z+%7FU&YuP}?_fHp4>^u?rLLv-n8tKUt>|`aPcv;J>noeOL0$HZn6~arcR4v*cl~ja zLLf=9ET`1tYcXNj%)H^#zsBk zu*YRfM5B9MC+l_lgQZk8=Nf|sjb-MI9vaadHOVAbR3V=(tBh@|y`!O}ZAaIIa&^tx zbrp)Tm%L|t=3}Oj9iBFI@8Fo`W(-?5?E@ou(>2qUF=T6##v0VivaeOOJ{ld(rOn54 zrgucGktDyhdP7v%r<2Luj?PEZ)w7c5ziC4>I?g5CS%XSFP`JG=stmb&W?Ink&U!@| zIz-#6x`C<2CM7y-X=%e!by?Wi)~ZBD^1`d?uAuRr3MD$4aV95eDQ?i#-Vu%N=Vtpf z*Xy4$Y?{)?f$eUZ(ioR@>N=m0RFg;){Qa*G)Yx{ME}fiAM2AH%>KcW<9Kr zO|UGRVJFxN>@+*W&at=HhwM{!k$uB{U_Y_n*zfEQ_9r4J#cGtH995`A9X4YNn$eC9 zB+!e8F@Q%fh;d9HjSO^5!bJ{wOrwA&@f4oMGk6v+;}yJ$H}N*!#d~-kAK^26jxX>f zzQ*_X5x?M9F~7(hpLYlI4FG>rW!{-3J_q02BB!p-=h#jnw6g2^<@2R7LE@Wku8h}i z+1kAQzRoKoShVvCm^q(}J_7~CeCo|n%ir}2MD<%@)yl1NCt>jk878tChb4YC)K#MQ zrr2!~@l2KcN2M-SD$_|2vbtEkB&iW0X^1t+M18eL$Xb+EiAb)l5Yjf~UYU-8S}dgP zNet8>pG(9Mxtp0+I*UJqX#?DPgEU562sV! z6f~miAy`CL2ZwP4GdPChcp{+e2|S1A@gh#*CA@~$@di=%G|u2G&Jl&*!3X#R7jOxe z7m>Da5oy0$NZNcdYg>+efLiBhzEB~2y5=4z5*Dg>{D1%Q-~X@qJVFDZ2SN}0e;z<_ zPqL?r>@W8w=CO91@&sj`c)x-`Uxf-k94GX{al$Kq7*ah>UAayoz=A+(q4b}B2oS%7 O!}~wH|9$@5sKq}!a2G`Y diff --git a/tests/.DS_Store b/tests/.DS_Store deleted file mode 100644 index 1f1d4a3fff6e5c568b05145c2c8139d6f7c7c07c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 10244 zcmeI1dvF!i9mmi2^4bjxSuhA(@4_Vk2^t_Igb)F+vFc2#W(K8W|FE5D`$x6aKGm7_ch1?p~MIld{D{ziA&J+QfaE@a>qiqAB$$cMtHJ!rx**HmCA9uTD1M+c9Zna|YR* z!GAOS9SX$Tsa;%DXGlmJK0^O_9yW7WmgQK6c@y{VPKru?l^U`w*Q>5Ri^z?ZpZCzEowyy3(ReZF*zPc*Dv3Apm z6RNU!)rPG*`Ua03AHDg+$$RC<;Li@Mv}mOFO&+H04mYQ4KFr8?FwAqoFx8T|+C1a> zw)UOct{$u3$#h!B&0f9KrIGHSWJlH+RTXsQcPrH+>_SsJ}8W*D-<`36DNo?ObhDQ9`d^a@20?}!`a+QBq^ z-A*UX-;!4J)6@^WeU(ve9N;C*S(Bb=zrh;gO0CN!&nS9QR$Ql5Yh6c30IKfFoLa5U z*kdPCrmgB}`JT<%7NdJu4q4UPWad_Fke`>|YuDx!@^;+w+SNxmvh0MzqUAj2F z>WcLn8@4s&;n?+EX>0~EJr1(u>}ci7ou&$PV7ZDdaxe{ zVd4-D!@?1G$YB^qNy4|_tN0qej&BMHe}^P|4<5q9cm&@kDgOkI;qknbU%=1tGRE;1 z-Yybud!cag`^mx`?#yOvCv%uexZG9d60MSKi0l9brpH`)<}8@?QXuUK%qsb;n57c4 zmX40DZK&B)6|Za9d{Jm|DA9F6Xx&eRQ;c;2xXuJ)Ed*CogmL?n*!bKamY-B~aAL() zh``<2B#Bj~O(fQZFeCz%154t9f;2jrOvbWkA(`~kimYG0EE=6SANXXte05ZkNl*F} zudLD}nFvg>Y4rvzDrXKo?E|N7lNJqT5WUUM+)}1R^HY(Zx9yr}v}jf$FiC1P(@ zDRHuotAd>;lStA-k}1!95#Keeg|)LjTEUI7+u1$r6anfCdy@Tvy~572x7Z)qyX^1m zU+mxPKZsy1Mf!Zg)Do=1YKr$YsKGW|LovStUqA8o$A-cuipHFL)2{%MZ?@X=gA1Y4H)+sdfEvc-l_F z*4n18t_!%dhOfvP^I|AcKml$hit?h6l6Ww*JeP_i#pe=_k$_9(v6Xxw`$*v%|u1ABAYcs8_wqqAbb~ie)N35=rB-?FGfono zq;zj5Jl&0ZaUZ@*c=`dYv>p{Jt z`AuH1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3 zem<@ulZcFPQ@L2!n>{z**++&mCkOWA81W14cNZlEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ zLs35+`xjp>T0H1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3 zem<@ulZcFPQ@L2!n>{z**++&mCkOWA81W14cNZlEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ zLs35+`xjp>T0 Date: Thu, 15 Jul 2021 12:48:58 -0600 Subject: [PATCH 32/58] Update ddtrace/contrib/mariadb/__init__.py Co-authored-by: Kyle Verhoog --- ddtrace/contrib/mariadb/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ddtrace/contrib/mariadb/__init__.py b/ddtrace/contrib/mariadb/__init__.py index 55ff7bf58d4..b5390c089c2 100644 --- a/ddtrace/contrib/mariadb/__init__.py +++ b/ddtrace/contrib/mariadb/__init__.py @@ -45,7 +45,7 @@ conn = mariadb.connector.connect(user="alice", password="b0b", host="localhost", port=3306, database="test") # Use a pin to override the service name for this connection. - Pin.override(conn, service='mariadb-users') + Pin.override(conn, service="mariadb-users") cursor = conn.cursor() cursor.execute("SELECT 6*7 AS the_answer;") From 597a69d1b99f117c0fe7d6977d06c0177bf2f13d Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Thu, 15 Jul 2021 12:49:20 -0600 Subject: [PATCH 33/58] Update tests/contrib/mariadb/test_mariadb.py Co-authored-by: Kyle Verhoog --- tests/contrib/mariadb/test_mariadb.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/contrib/mariadb/test_mariadb.py b/tests/contrib/mariadb/test_mariadb.py index f09f5a0b781..fbf643372f8 100644 --- a/tests/contrib/mariadb/test_mariadb.py +++ b/tests/contrib/mariadb/test_mariadb.py @@ -64,7 +64,7 @@ def test_simple_query(connection, tracer): ) -def test_query_many(connection, tracer): +def test_query_executemany(connection, tracer): # tests that the executemany method is correctly wrapped. tracer.enabled = False cursor = connection.cursor() From 6ddcde4830f9679a4a88b7c82f47ae32595e3961 Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Thu, 15 Jul 2021 12:49:36 -0600 Subject: [PATCH 34/58] Update tests/contrib/mariadb/test_mariadb.py Co-authored-by: Kyle Verhoog --- tests/contrib/mariadb/test_mariadb.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/contrib/mariadb/test_mariadb.py b/tests/contrib/mariadb/test_mariadb.py index fbf643372f8..a66d0d9fccd 100644 --- a/tests/contrib/mariadb/test_mariadb.py +++ b/tests/contrib/mariadb/test_mariadb.py @@ -65,7 +65,6 @@ def test_simple_query(connection, tracer): def test_query_executemany(connection, tracer): - # tests that the executemany method is correctly wrapped. tracer.enabled = False cursor = connection.cursor() From 1903bc2540814e5e13efa37de708f71d59095678 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Thu, 15 Jul 2021 12:55:31 -0600 Subject: [PATCH 35/58] fix merge conflict --- benchmarks/start_span/benchmark | 24 +++++++ benchmarks/start_span/entrypoint | 22 ++++++ benchmarks/start_span/requirements.txt | 1 + benchmarks/start_span/scenario.py | 49 +++++++++++++ benchmarks/start_span/util.py | 45 ++++++++++++ tests/contrib/mariadb/test_mariadb.py | 95 -------------------------- 6 files changed, 141 insertions(+), 95 deletions(-) create mode 100755 benchmarks/start_span/benchmark create mode 100755 benchmarks/start_span/entrypoint create mode 100644 benchmarks/start_span/requirements.txt create mode 100644 benchmarks/start_span/scenario.py create mode 100755 benchmarks/start_span/util.py diff --git a/benchmarks/start_span/benchmark b/benchmarks/start_span/benchmark new file mode 100755 index 00000000000..228d0cdceff --- /dev/null +++ b/benchmarks/start_span/benchmark @@ -0,0 +1,24 @@ +#!/bin/bash + +set -o errexit +set -o pipefail +set -o nounset + +mkdir -p /artifacts/${RUN_ID} + +RESULTS_1=/artifacts/${RUN_ID}/${DDTRACE_GIT_COMMIT_ID_1}.json +RESULTS_2=/artifacts/${RUN_ID}/${DDTRACE_GIT_COMMIT_ID_2}.json + +# append venvs with ddtrace to sys.path + +PYTHONPATH=/app/.venv_1/lib/python3.9/site-packages \ + python scenario.py \ + --copy-env \ + -o ${RESULTS_1} + +PYTHONPATH=/app/.venv_2/lib/python3.9/site-packages \ + python scenario.py \ + --copy-env \ + -o ${RESULTS_2} + +pyperf compare_to --table ${RESULTS_2} ${RESULTS_1} diff --git a/benchmarks/start_span/entrypoint b/benchmarks/start_span/entrypoint new file mode 100755 index 00000000000..77375b07599 --- /dev/null +++ b/benchmarks/start_span/entrypoint @@ -0,0 +1,22 @@ +#!/bin/bash + +set -o errexit +set -o pipefail +set -o nounset + +if [[ -z "${RUN_ID}" ]]; then + RUN_ID=$(uuidgen) +fi + +python3 -m venv /app/.venv_1 +python3 -m venv /app/.venv_2 + +source /app/.venv_1/bin/activate +pip install git+https://github.com/Datadog/dd-trace-py@${DDTRACE_GIT_COMMIT_ID_1} +deactivate + +source /app/.venv_2/bin/activate +pip install git+https://github.com/Datadog/dd-trace-py@${DDTRACE_GIT_COMMIT_ID_2} +deactivate + +exec "$@" diff --git a/benchmarks/start_span/requirements.txt b/benchmarks/start_span/requirements.txt new file mode 100644 index 00000000000..0e517cc83a7 --- /dev/null +++ b/benchmarks/start_span/requirements.txt @@ -0,0 +1 @@ +pyperf diff --git a/benchmarks/start_span/scenario.py b/benchmarks/start_span/scenario.py new file mode 100644 index 00000000000..d592998af2a --- /dev/null +++ b/benchmarks/start_span/scenario.py @@ -0,0 +1,49 @@ +import os + +import pyperf +from util import gen_traces + +from ddtrace.internal.encoding import Encoder + + +try: + from ddtrace.internal._encoding import BufferedEncoder + + def init_encoder(max_size=8 << 20, max_item_size=8 << 20): + return Encoder(max_size, max_item_size) + + +except: + + def init_encoder(): + return Encoder() + + +VARIANTS = [ + dict(ntraces=1, nspans=1000), + dict(ntraces=100, nspans=1000), + dict(ntraces=1, nspans=1000, ntags=1, ltags=16), + dict(ntraces=1, nspans=1000, ntags=100, ltags=128), + dict(ntraces=1, nspans=1000, nmetrics=1), + dict(ntraces=1, nspans=1000, nmetrics=100), +] + + +def time_encode(loops, encoder, traces): + range_it = range(loops) + t0 = pyperf.perf_counter() + for _ in range_it: + encoder.encode_traces(traces) + dt = pyperf.perf_counter() - t0 + return dt + + +if __name__ == "__main__": + runner = pyperf.Runner() + runner.metadata["scenario"] = "encoder" + for variant in VARIANTS: + encoder = init_encoder() + traces = gen_traces(**variant) + name = "|".join(f"{k}:{v}" for (k, v) in variant.items()) + metadata = {} + runner.bench_time_func(name, time_encode, encoder, traces, metadata=metadata) diff --git a/benchmarks/start_span/util.py b/benchmarks/start_span/util.py new file mode 100755 index 00000000000..020e0cb644b --- /dev/null +++ b/benchmarks/start_span/util.py @@ -0,0 +1,45 @@ +import random +import string + +from ddtrace.span import Span + + +def rands(size=6, chars=string.ascii_uppercase + string.digits): + return "".join(random.choice(chars) for _ in range(size)) + + +# set of randomly generated span attributes to be used in traces +SPAN_NAMES = [rands(size=16) for _ in range(256)] +RESOURCES = [rands(size=16) for _ in range(256)] +SERVICES = [rands(size=16) for _ in range(16)] +TAG_KEYS = [rands(size=16) for _ in range(256)] +METRIC_KEYS = [rands(size=16) for _ in range(256)] + + +def gen_traces(ntraces=1, nspans=1, ntags=0, ltags=0, nmetrics=0): + traces = [] + for _ in range(ntraces): + trace = [] + tag_values = [rands(size=ltags) for _ in range(ntags)] + for i in range(0, nspans): + # first span is root so has no parent otherwise parent is root span + parent_id = trace[0].span_id if i > 0 else None + span_name = random.sample(SPAN_NAMES, 1)[0] + resource = random.sample(RESOURCES, 1)[0] + service = random.sample(SERVICES, 1)[0] + tag_keys = random.sample(TAG_KEYS, ntags) + with Span(None, span_name, resource=resource, service=service, parent_id=parent_id) as span: + if ntags > 0: + span.set_tags(dict(zip(random.sample(TAG_KEYS, ntags), random.sample(tag_values, ntags)))) + if nmetrics > 0: + span.set_metrics( + dict( + zip( + random.sample(METRIC_KEYS, nmetrics), + [random.randint(0, 2 ** 16) for _ in range(nmetrics)], + ) + ) + ) + trace.append(span) + traces.append(trace) + return traces diff --git a/tests/contrib/mariadb/test_mariadb.py b/tests/contrib/mariadb/test_mariadb.py index f09f5a0b781..e218f5d0eb0 100644 --- a/tests/contrib/mariadb/test_mariadb.py +++ b/tests/contrib/mariadb/test_mariadb.py @@ -99,101 +99,6 @@ def test_query_many(connection, tracer): cursor.execute("drop table if exists dummy") -<<<<<<< HEAD -======= -def test_query_many_fetchall(tracer): - with override_config("mariadb", dict(trace_fetch_methods=True)): - connection = get_connection(tracer) - - # tests that the executemany method is correctly wrapped. - tracer.enabled = False - cursor = connection.cursor() - - cursor.execute( - """ - create table if not exists dummy ( - dummy_key VARCHAR(32) PRIMARY KEY, - dummy_value TEXT NOT NULL)""" - ) - tracer.enabled = True - - stmt = "INSERT INTO dummy (dummy_key, dummy_value) VALUES (%s, %s)" - data = [ - ("foo", "this is foo"), - ("bar", "this is bar"), - ] - cursor.executemany(stmt, data) - query = "SELECT dummy_key, dummy_value FROM dummy ORDER BY dummy_key" - cursor.execute(query) - rows = cursor.fetchall() - assert len(rows) == 2 - assert rows[0][0] == "bar" - assert rows[0][1] == "this is bar" - assert rows[1][0] == "foo" - assert rows[1][1] == "this is foo" - - spans = tracer.pop() - assert len(spans) == 3 - span = spans[-1] - assert span.get_tag("mariadb.query") is None - cursor.execute("drop table if exists dummy") - - assert spans[2].name == "mariadb.query.fetchall" - - -def test_query_proc(connection, tracer): - - # create a procedure - tracer.enabled = False - cursor = connection.cursor() - cursor.execute("DROP PROCEDURE IF EXISTS sp_sum") - cursor.execute( - """ - CREATE PROCEDURE sp_sum (IN p1 INTEGER, IN p2 INTEGER, OUT p3 INTEGER) - BEGIN - SET p3 := p1 + p2; - END;""" - ) - - tracer.enabled = True - proc = "sp_sum" - data = (40, 2, None) - cursor.callproc(proc, data) - - spans = tracer.pop() - assert spans, spans - - # number of spans depends on mariadb implementation details, - # typically, internal calls to execute, but at least we - # can expect the last closed span to be our proc. - span = spans[-1] - assert_is_measured(span) - assert span.service == "mariadb" - assert span.name == "mariadb.query" - assert span.span_type == "sql" - assert span.error == 0 - assert span.get_metric("out.port") == 3306 - assert_dict_issuperset( - span.meta, - { - "out.host": u"127.0.0.1", - "db.name": u"test", - "db.user": u"test", - }, - ) - assert span.get_tag("mariadb.query") is None - - -def test_commit(connection, tracer): - connection.commit() - spans = tracer.pop() - assert len(spans) == 1 - span = spans[0] - assert span.service == "mariadb" - assert span.name == "mariadb.connection.commit" - - ->>>>>>> faad6ebd654e6c8d8202997d87b102bbb83fa31b def test_rollback(connection, tracer): connection.rollback() spans = tracer.pop() From cb8cbbe93c36645ef0a475517ef4e9a8bdc50ea7 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Thu, 15 Jul 2021 12:56:17 -0600 Subject: [PATCH 36/58] remove benchmark changes --- benchmarks/start_span/benchmark | 24 ------------- benchmarks/start_span/entrypoint | 22 ------------ benchmarks/start_span/requirements.txt | 1 - benchmarks/start_span/scenario.py | 49 -------------------------- benchmarks/start_span/util.py | 45 ----------------------- 5 files changed, 141 deletions(-) delete mode 100755 benchmarks/start_span/benchmark delete mode 100755 benchmarks/start_span/entrypoint delete mode 100644 benchmarks/start_span/requirements.txt delete mode 100644 benchmarks/start_span/scenario.py delete mode 100755 benchmarks/start_span/util.py diff --git a/benchmarks/start_span/benchmark b/benchmarks/start_span/benchmark deleted file mode 100755 index 228d0cdceff..00000000000 --- a/benchmarks/start_span/benchmark +++ /dev/null @@ -1,24 +0,0 @@ -#!/bin/bash - -set -o errexit -set -o pipefail -set -o nounset - -mkdir -p /artifacts/${RUN_ID} - -RESULTS_1=/artifacts/${RUN_ID}/${DDTRACE_GIT_COMMIT_ID_1}.json -RESULTS_2=/artifacts/${RUN_ID}/${DDTRACE_GIT_COMMIT_ID_2}.json - -# append venvs with ddtrace to sys.path - -PYTHONPATH=/app/.venv_1/lib/python3.9/site-packages \ - python scenario.py \ - --copy-env \ - -o ${RESULTS_1} - -PYTHONPATH=/app/.venv_2/lib/python3.9/site-packages \ - python scenario.py \ - --copy-env \ - -o ${RESULTS_2} - -pyperf compare_to --table ${RESULTS_2} ${RESULTS_1} diff --git a/benchmarks/start_span/entrypoint b/benchmarks/start_span/entrypoint deleted file mode 100755 index 77375b07599..00000000000 --- a/benchmarks/start_span/entrypoint +++ /dev/null @@ -1,22 +0,0 @@ -#!/bin/bash - -set -o errexit -set -o pipefail -set -o nounset - -if [[ -z "${RUN_ID}" ]]; then - RUN_ID=$(uuidgen) -fi - -python3 -m venv /app/.venv_1 -python3 -m venv /app/.venv_2 - -source /app/.venv_1/bin/activate -pip install git+https://github.com/Datadog/dd-trace-py@${DDTRACE_GIT_COMMIT_ID_1} -deactivate - -source /app/.venv_2/bin/activate -pip install git+https://github.com/Datadog/dd-trace-py@${DDTRACE_GIT_COMMIT_ID_2} -deactivate - -exec "$@" diff --git a/benchmarks/start_span/requirements.txt b/benchmarks/start_span/requirements.txt deleted file mode 100644 index 0e517cc83a7..00000000000 --- a/benchmarks/start_span/requirements.txt +++ /dev/null @@ -1 +0,0 @@ -pyperf diff --git a/benchmarks/start_span/scenario.py b/benchmarks/start_span/scenario.py deleted file mode 100644 index d592998af2a..00000000000 --- a/benchmarks/start_span/scenario.py +++ /dev/null @@ -1,49 +0,0 @@ -import os - -import pyperf -from util import gen_traces - -from ddtrace.internal.encoding import Encoder - - -try: - from ddtrace.internal._encoding import BufferedEncoder - - def init_encoder(max_size=8 << 20, max_item_size=8 << 20): - return Encoder(max_size, max_item_size) - - -except: - - def init_encoder(): - return Encoder() - - -VARIANTS = [ - dict(ntraces=1, nspans=1000), - dict(ntraces=100, nspans=1000), - dict(ntraces=1, nspans=1000, ntags=1, ltags=16), - dict(ntraces=1, nspans=1000, ntags=100, ltags=128), - dict(ntraces=1, nspans=1000, nmetrics=1), - dict(ntraces=1, nspans=1000, nmetrics=100), -] - - -def time_encode(loops, encoder, traces): - range_it = range(loops) - t0 = pyperf.perf_counter() - for _ in range_it: - encoder.encode_traces(traces) - dt = pyperf.perf_counter() - t0 - return dt - - -if __name__ == "__main__": - runner = pyperf.Runner() - runner.metadata["scenario"] = "encoder" - for variant in VARIANTS: - encoder = init_encoder() - traces = gen_traces(**variant) - name = "|".join(f"{k}:{v}" for (k, v) in variant.items()) - metadata = {} - runner.bench_time_func(name, time_encode, encoder, traces, metadata=metadata) diff --git a/benchmarks/start_span/util.py b/benchmarks/start_span/util.py deleted file mode 100755 index 020e0cb644b..00000000000 --- a/benchmarks/start_span/util.py +++ /dev/null @@ -1,45 +0,0 @@ -import random -import string - -from ddtrace.span import Span - - -def rands(size=6, chars=string.ascii_uppercase + string.digits): - return "".join(random.choice(chars) for _ in range(size)) - - -# set of randomly generated span attributes to be used in traces -SPAN_NAMES = [rands(size=16) for _ in range(256)] -RESOURCES = [rands(size=16) for _ in range(256)] -SERVICES = [rands(size=16) for _ in range(16)] -TAG_KEYS = [rands(size=16) for _ in range(256)] -METRIC_KEYS = [rands(size=16) for _ in range(256)] - - -def gen_traces(ntraces=1, nspans=1, ntags=0, ltags=0, nmetrics=0): - traces = [] - for _ in range(ntraces): - trace = [] - tag_values = [rands(size=ltags) for _ in range(ntags)] - for i in range(0, nspans): - # first span is root so has no parent otherwise parent is root span - parent_id = trace[0].span_id if i > 0 else None - span_name = random.sample(SPAN_NAMES, 1)[0] - resource = random.sample(RESOURCES, 1)[0] - service = random.sample(SERVICES, 1)[0] - tag_keys = random.sample(TAG_KEYS, ntags) - with Span(None, span_name, resource=resource, service=service, parent_id=parent_id) as span: - if ntags > 0: - span.set_tags(dict(zip(random.sample(TAG_KEYS, ntags), random.sample(tag_values, ntags)))) - if nmetrics > 0: - span.set_metrics( - dict( - zip( - random.sample(METRIC_KEYS, nmetrics), - [random.randint(0, 2 ** 16) for _ in range(nmetrics)], - ) - ) - ) - trace.append(span) - traces.append(trace) - return traces From 721e00aa5f485af3500849e37a08774508cd6a89 Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Thu, 15 Jul 2021 12:57:13 -0600 Subject: [PATCH 37/58] Update tests/utils.py Co-authored-by: Kyle Verhoog --- tests/utils.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/utils.py b/tests/utils.py index a9b4d131f52..4f3610df228 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -917,7 +917,6 @@ def wrapper(wrapped, instance, args, kwargs): else token_override ) - # Use variant that applies to update test token. One must apply. If none # apply, the test should have been marked as skipped. if variants: From 7c37778fc94676b684d0bff2f0b972bdce8d4313 Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Thu, 15 Jul 2021 12:59:13 -0600 Subject: [PATCH 38/58] Update ddtrace/contrib/mariadb/__init__.py Co-authored-by: Kyle Verhoog --- ddtrace/contrib/mariadb/__init__.py | 1 - 1 file changed, 1 deletion(-) diff --git a/ddtrace/contrib/mariadb/__init__.py b/ddtrace/contrib/mariadb/__init__.py index b5390c089c2..7cc24a5f4f1 100644 --- a/ddtrace/contrib/mariadb/__init__.py +++ b/ddtrace/contrib/mariadb/__init__.py @@ -50,7 +50,6 @@ cursor = conn.cursor() cursor.execute("SELECT 6*7 AS the_answer;") -Help on mariadb.connector can be found on: https://mariadb-corporation.github.io/mariadb-connector-python/usage.html """ from ...utils.importlib import require_modules From 24616bb219ff1fbc808bf0f2fb536b23da25d11d Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Thu, 15 Jul 2021 12:59:48 -0600 Subject: [PATCH 39/58] Update .gitignore Co-authored-by: Kyle Verhoog --- .gitignore | 1 - 1 file changed, 1 deletion(-) diff --git a/.gitignore b/.gitignore index 159b592e0bc..fff4d890744 100644 --- a/.gitignore +++ b/.gitignore @@ -108,4 +108,3 @@ ENV/ .vscode/ #Mac stuff -.DS_Store From 8c444d03819b129c43bf5f1da01adc0d46cf1c00 Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Thu, 15 Jul 2021 13:02:01 -0600 Subject: [PATCH 40/58] Update ddtrace/contrib/mariadb/patch.py Co-authored-by: Yun Kim <35776586+Yun-Kim@users.noreply.github.com> --- ddtrace/contrib/mariadb/patch.py | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/ddtrace/contrib/mariadb/patch.py b/ddtrace/contrib/mariadb/patch.py index a1deb703fc3..cb5ce232efe 100644 --- a/ddtrace/contrib/mariadb/patch.py +++ b/ddtrace/contrib/mariadb/patch.py @@ -5,12 +5,11 @@ from ddtrace.vendor import wrapt from ddtrace.utils import get_argument_value -from ...ext import db -from ...ext import net - -from ...utils.formats import asbool -from ...utils.formats import get_env -from ...utils.wrappers import unwrap +from ddtrace.ext import db +from ddtrace.ext import net +from ddtrace.utils.formats import asbool +from ddtrace.utils.formats import get_env +from ddtrace.utils.wrappers import unwrap config._add( From 92eac3e3e3a7fb31ce341f4781bb7289f48641ab Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Thu, 15 Jul 2021 13:14:13 -0600 Subject: [PATCH 41/58] Update .gitignore Co-authored-by: Kyle Verhoog --- .gitignore | 1 - 1 file changed, 1 deletion(-) diff --git a/.gitignore b/.gitignore index fff4d890744..3f480bb3b46 100644 --- a/.gitignore +++ b/.gitignore @@ -106,5 +106,4 @@ ENV/ # VS Code .vscode/ - #Mac stuff From f874781f12aaddda1024a254d86a181f3c9adbea Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Thu, 15 Jul 2021 13:14:20 -0600 Subject: [PATCH 42/58] Update .gitignore Co-authored-by: Kyle Verhoog --- .gitignore | 1 - 1 file changed, 1 deletion(-) diff --git a/.gitignore b/.gitignore index 3f480bb3b46..66e602f510b 100644 --- a/.gitignore +++ b/.gitignore @@ -106,4 +106,3 @@ ENV/ # VS Code .vscode/ -#Mac stuff From d10c59fba031779723822ec59319d578234ff1ea Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Thu, 15 Jul 2021 16:10:45 -0600 Subject: [PATCH 43/58] fix spelling in circleci --- .circleci/config.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index bc04a6d90a7..7cc710a797e 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -625,11 +625,11 @@ jobs: pattern: "grpc" snapshot: true - maridb: + mariadb: <<: *machine_executor steps: - run_test: - pattern: 'maridb$' + pattern: 'mariadb$' snapshot: true docker_services: "mariadb" From 906dd85288611455019758de01809faba095fdfb Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Fri, 16 Jul 2021 14:09:04 -0600 Subject: [PATCH 44/58] fixing formatting --- tests/contrib/config.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/tests/contrib/config.py b/tests/contrib/config.py index 472ccddc559..0abc5ea41bf 100644 --- a/tests/contrib/config.py +++ b/tests/contrib/config.py @@ -41,11 +41,11 @@ } MARIADB_CONFIG = { - 'host': '127.0.0.1', - 'port': int(os.getenv('TEST_MARIADB_PORT', 3306)), - 'user': os.getenv('TEST_MARIADB_USER', 'test'), - 'password': os.getenv('TEST_MARIADB_PASSWORD', 'test'), - 'database': os.getenv('TEST_MARIADB_DATABASE', 'test'), + "host": "127.0.0.1", + "port": int(os.getenv("TEST_MARIADB_PORT", 3306)), + "user": os.getenv("TEST_MARIADB_USER", "test"), + "password": os.getenv("TEST_MARIADB_PASSWORD", "test"), + "database": os.getenv("TEST_MARIADB_DATABASE", "test"), } REDIS_CONFIG = { From 8fc85961b4d824150dac2c96a1302994168660a5 Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Fri, 16 Jul 2021 15:31:54 -0600 Subject: [PATCH 45/58] Remove changes to Dockerfile.buster --- Dockerfile.buster | 3 --- 1 file changed, 3 deletions(-) diff --git a/Dockerfile.buster b/Dockerfile.buster index 81901dc9414..82b820f1981 100644 --- a/Dockerfile.buster +++ b/Dockerfile.buster @@ -54,9 +54,6 @@ RUN \ && echo "deb-src https://deb.nodesource.com/${NODE_VERSION} buster main" | tee -a /etc/apt/sources.list.d/nodesource.list \ && apt-get update \ && apt-get install -y --no-install-recommends nodejs \ - && apt-get install -y mariadb-server \ - && curl -sS https://downloads.mariadb.com/MariaDB/mariadb_repo_setup | bash \ - && apt-get install -y libmariadb3 \ # Cleaning up apt cache space && rm -rf /var/lib/apt/lists/* \ From 671771beac4de15a9f5d6eef439d94685364baf8 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Fri, 16 Jul 2021 16:35:57 -0600 Subject: [PATCH 46/58] flake8 formatting --- ddtrace/contrib/mariadb/__init__.py | 3 ++- ddtrace/contrib/mariadb/patch.py | 5 ++--- tests/contrib/mariadb/test_mariadb.py | 19 ++++++++----------- 3 files changed, 12 insertions(+), 15 deletions(-) diff --git a/ddtrace/contrib/mariadb/__init__.py b/ddtrace/contrib/mariadb/__init__.py index 7cc24a5f4f1..68bbde1a56e 100644 --- a/ddtrace/contrib/mariadb/__init__.py +++ b/ddtrace/contrib/mariadb/__init__.py @@ -1,5 +1,6 @@ """ -The MariaDB integration instruments the :ref:`MariaDB library` to trace queries. +The MariaDB integration instruments the +:ref:`MariaDB library` to trace queries. Enabling diff --git a/ddtrace/contrib/mariadb/patch.py b/ddtrace/contrib/mariadb/patch.py index cb5ce232efe..4b90cc8070a 100644 --- a/ddtrace/contrib/mariadb/patch.py +++ b/ddtrace/contrib/mariadb/patch.py @@ -1,15 +1,14 @@ import mariadb + from ddtrace import Pin from ddtrace import config from ddtrace.contrib.dbapi import TracedConnection -from ddtrace.vendor import wrapt -from ddtrace.utils import get_argument_value - from ddtrace.ext import db from ddtrace.ext import net from ddtrace.utils.formats import asbool from ddtrace.utils.formats import get_env from ddtrace.utils.wrappers import unwrap +from ddtrace.vendor import wrapt config._add( diff --git a/tests/contrib/mariadb/test_mariadb.py b/tests/contrib/mariadb/test_mariadb.py index e9cb1468439..1ea795c05c1 100644 --- a/tests/contrib/mariadb/test_mariadb.py +++ b/tests/contrib/mariadb/test_mariadb.py @@ -1,19 +1,16 @@ -from logging import ERROR -import pytest import mariadb +import pytest + +from ddtrace import Pin +from ddtrace.constants import ANALYTICS_SAMPLE_RATE_KEY +from ddtrace.contrib.mariadb import patch +from ddtrace.contrib.mariadb import unpatch +from tests.contrib.config import MARIADB_CONFIG from tests.utils import DummyTracer -from tests.utils import assert_is_measured from tests.utils import assert_dict_issuperset +from tests.utils import assert_is_measured from tests.utils import override_config -from tests.utils import TracerTestCase -from ddtrace.contrib.mariadb import patch -from ddtrace.contrib.mariadb import unpatch -from ddtrace import Pin -from ddtrace import tracer as global_tracer -from ddtrace.constants import ANALYTICS_SAMPLE_RATE_KEY from tests.utils import snapshot -from tests.contrib.config import MARIADB_CONFIG -import unittest @pytest.fixture From 88e7cc141f8f7dcdb4c3a6e9b29d3957ebc0a846 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Mon, 19 Jul 2021 09:10:18 -0600 Subject: [PATCH 47/58] recreated snapshots and added mariadb to spelling_wordlist --- docs/spelling_wordlist.txt | 1 + ...adb.test_analytics_with_rate_snapshot.snap | 8 +++---- ....test_analytics_without_rate_snapshot.snap | 8 +++---- ...adb.test_query_many_fetchall_snapshot.snap | 24 +++++++++---------- ...test_mariadb.test_query_proc_snapshot.snap | 8 +++---- ...y_with_several_rows_fetchall_snapshot.snap | 16 ++++++------- ...test_query_with_several_rows_snapshot.snap | 8 +++---- ....test_simple_malformed_query_snapshot.snap | 8 +++---- ...b.test_simple_query_fetchall_snapshot.snap | 16 ++++++------- ...st_mariadb.test_simple_query_snapshot.snap | 8 +++---- ...ice_snapshot_DD_MARIADB_SERVICE_mysvc.snap | 8 +++---- ...ied_service_snapshot_DD_SERVICE_mysvc.snap | 8 +++---- 12 files changed, 61 insertions(+), 60 deletions(-) diff --git a/docs/spelling_wordlist.txt b/docs/spelling_wordlist.txt index 08304bde6e8..108e92a923a 100644 --- a/docs/spelling_wordlist.txt +++ b/docs/spelling_wordlist.txt @@ -71,6 +71,7 @@ kwarg lifecycle lookups mako +mariadb memcached metadata microservices diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_analytics_with_rate_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_analytics_with_rate_snapshot.snap index cbcf5727441..64b65257f0b 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_analytics_with_rate_snapshot.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_analytics_with_rate_snapshot.snap @@ -6,9 +6,9 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626232121496795700 - "duration" 738700 - "meta" {"runtime-id" "1a5d5390d899424fa102e911eab81c65" + "start" 1626232692638571500 + "duration" 638700 + "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} @@ -16,7 +16,7 @@ "_dd.measured" 1 "_dd1.sr.eausr" 0.5 "_sampling_priority_v1" 1 - "system.pid" 12141 + "system.pid" 12385 "_dd.tracer_kr" 1.0 "sql.rows" 0 "db.rowcount" 0 diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_analytics_without_rate_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_analytics_without_rate_snapshot.snap index 700eb3d64df..166ed22be8f 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_analytics_without_rate_snapshot.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_analytics_without_rate_snapshot.snap @@ -6,9 +6,9 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626232121520795500 - "duration" 1208900 - "meta" {"runtime-id" "1a5d5390d899424fa102e911eab81c65" + "start" 1626232692662242600 + "duration" 636100 + "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} @@ -16,7 +16,7 @@ "_dd.measured" 1 "_dd1.sr.eausr" 1.0 "_sampling_priority_v1" 1 - "system.pid" 12141 + "system.pid" 12385 "_dd.tracer_kr" 1.0 "sql.rows" 0 "db.rowcount" 0 diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_many_fetchall_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_many_fetchall_snapshot.snap index c10628e5580..a7f70689da7 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_many_fetchall_snapshot.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_many_fetchall_snapshot.snap @@ -6,9 +6,9 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626232121383370200 - "duration" 1907900 - "meta" {"runtime-id" "1a5d5390d899424fa102e911eab81c65" + "start" 1626232692394915800 + "duration" 1561300 + "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test" @@ -16,7 +16,7 @@ "metrics" {"_dd.agent_psr" 1.0 "_dd.measured" 1 "_sampling_priority_v1" 1 - "system.pid" 12141 + "system.pid" 12385 "out.port" 3306 "db.rowcount" 2 "sql.rows" 2 @@ -29,16 +29,16 @@ "span_id" 0 "trace_id" 1 "parent_id" nil - "start" 1626232121385712800 - "duration" 1929600 - "meta" {"runtime-id" "1a5d5390d899424fa102e911eab81c65" + "start" 1626232692397364100 + "duration" 1868900 + "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_dd.measured" 1 "_sampling_priority_v1" 1 - "system.pid" 12141 + "system.pid" 12385 "out.port" 3306 "db.rowcount" 0 "sql.rows" 0 @@ -51,15 +51,15 @@ "span_id" 0 "trace_id" 2 "parent_id" nil - "start" 1626232121387781100 - "duration" 62900 - "meta" {"runtime-id" "1a5d5390d899424fa102e911eab81c65" + "start" 1626232692399424200 + "duration" 75000 + "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_sampling_priority_v1" 1 - "system.pid" 12141 + "system.pid" 12385 "out.port" 3306 "db.rowcount" 2 "sql.rows" 2 diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_proc_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_proc_snapshot.snap index 9d794c9b40f..beacd474d24 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_proc_snapshot.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_proc_snapshot.snap @@ -6,16 +6,16 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626220628259642300 - "duration" 3986300 - "meta" {"runtime-id" "0d2b28a27ae249f88ff7ed45801df80a" + "start" 1626232692612789400 + "duration" 1446200 + "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_dd.measured" 1 "_sampling_priority_v1" 1 - "system.pid" 11226 + "system.pid" 12385 "out.port" 3306 "db.rowcount" 0 "sql.rows" 0 diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_with_several_rows_fetchall_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_with_several_rows_fetchall_snapshot.snap index b103f2cd7df..5bd0194203b 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_with_several_rows_fetchall_snapshot.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_with_several_rows_fetchall_snapshot.snap @@ -6,16 +6,16 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626232121340582800 - "duration" 3323200 - "meta" {"runtime-id" "1a5d5390d899424fa102e911eab81c65" + "start" 1626232692364655200 + "duration" 640800 + "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_dd.measured" 1 "_sampling_priority_v1" 1 - "system.pid" 12141 + "system.pid" 12385 "out.port" 3306 "db.rowcount" 0 "sql.rows" 0 @@ -28,15 +28,15 @@ "span_id" 0 "trace_id" 1 "parent_id" nil - "start" 1626232121344409200 - "duration" 76200 - "meta" {"runtime-id" "1a5d5390d899424fa102e911eab81c65" + "start" 1626232692365859200 + "duration" 70000 + "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_sampling_priority_v1" 1 - "system.pid" 12141 + "system.pid" 12385 "out.port" 3306 "db.rowcount" 3 "sql.rows" 3 diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_with_several_rows_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_with_several_rows_snapshot.snap index d1d4e7edffb..3c9efc5be5a 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_with_several_rows_snapshot.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_with_several_rows_snapshot.snap @@ -6,16 +6,16 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626232121313193600 - "duration" 3258500 - "meta" {"runtime-id" "1a5d5390d899424fa102e911eab81c65" + "start" 1626232692342101400 + "duration" 2084200 + "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_dd.measured" 1 "_sampling_priority_v1" 1 - "system.pid" 12141 + "system.pid" 12385 "out.port" 3306 "db.rowcount" 0 "sql.rows" 0 diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_malformed_query_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_malformed_query_snapshot.snap index 3301406f2e6..aa3a2a1612b 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_malformed_query_snapshot.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_malformed_query_snapshot.snap @@ -6,9 +6,9 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626220628108996000 - "duration" 3201900 - "meta" {"runtime-id" "0d2b28a27ae249f88ff7ed45801df80a" + "start" 1626232692284132700 + "duration" 2013100 + "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test" @@ -18,7 +18,7 @@ "metrics" {"_dd.agent_psr" 1.0 "_dd.measured" 1 "_sampling_priority_v1" 1 - "system.pid" 11226 + "system.pid" 12385 "out.port" 3306 "db.rowcount" -1 "_dd.tracer_kr" 1.0}}]] diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_fetchall_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_fetchall_snapshot.snap index fb71cb61b0d..534532c5970 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_fetchall_snapshot.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_fetchall_snapshot.snap @@ -6,16 +6,16 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626220628154313200 - "duration" 2072900 - "meta" {"runtime-id" "0d2b28a27ae249f88ff7ed45801df80a" + "start" 1626232692316370400 + "duration" 911600 + "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_dd.measured" 1 "_sampling_priority_v1" 1 - "system.pid" 11226 + "system.pid" 12385 "out.port" 3306 "db.rowcount" 0 "sql.rows" 0 @@ -28,15 +28,15 @@ "span_id" 0 "trace_id" 1 "parent_id" nil - "start" 1626220628157443800 - "duration" 145100 - "meta" {"runtime-id" "0d2b28a27ae249f88ff7ed45801df80a" + "start" 1626232692317850500 + "duration" 72100 + "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_sampling_priority_v1" 1 - "system.pid" 11226 + "system.pid" 12385 "out.port" 3306 "db.rowcount" 1 "sql.rows" 1 diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_snapshot.snap index f3880e2f61b..fa732f64cd7 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_snapshot.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_snapshot.snap @@ -6,16 +6,16 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626220628062739900 - "duration" 1286200 - "meta" {"runtime-id" "0d2b28a27ae249f88ff7ed45801df80a" + "start" 1626232692262017600 + "duration" 786800 + "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_dd.measured" 1 "_sampling_priority_v1" 1 - "system.pid" 11226 + "system.pid" 12385 "out.port" 3306 "db.rowcount" 0 "sql.rows" 0 diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_MARIADB_SERVICE_mysvc.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_MARIADB_SERVICE_mysvc.snap index b56b9b71d71..ca023c730d3 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_MARIADB_SERVICE_mysvc.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_MARIADB_SERVICE_mysvc.snap @@ -6,16 +6,16 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626220627990819900 - "duration" 536900 - "meta" {"runtime-id" "7aa729b9f6e64ac0bed8d5d132bf4884" + "start" 1626232692202090900 + "duration" 581600 + "meta" {"runtime-id" "9eb01c32305f409999b99721fc511d80" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_dd.measured" 1 "_sampling_priority_v1" 1 - "system.pid" 11233 + "system.pid" 12392 "out.port" 3306 "db.rowcount" 0 "sql.rows" 0 diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_SERVICE_mysvc.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_SERVICE_mysvc.snap index 0a69d4dedce..ec05b8c8e7b 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_SERVICE_mysvc.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_SERVICE_mysvc.snap @@ -6,16 +6,16 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626220627053687400 - "duration" 894700 - "meta" {"runtime-id" "ef4c507bd1084bdab3a7cae496209583" + "start" 1626232691457749100 + "duration" 788000 + "meta" {"runtime-id" "cee61bc6db3640dfa9b933cef309c5d9" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_dd.measured" 1 "_sampling_priority_v1" 1 - "system.pid" 11230 + "system.pid" 12389 "out.port" 3306 "db.rowcount" 0 "sql.rows" 0 From 59ef78114a3f5f1b557cf4882e8396fdab646bc1 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Mon, 19 Jul 2021 11:42:35 -0600 Subject: [PATCH 48/58] changing test case so tracer flushes --- tests/contrib/mariadb/test_mariadb.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/contrib/mariadb/test_mariadb.py b/tests/contrib/mariadb/test_mariadb.py index 1ea795c05c1..7fa9b301317 100644 --- a/tests/contrib/mariadb/test_mariadb.py +++ b/tests/contrib/mariadb/test_mariadb.py @@ -135,6 +135,7 @@ def testcase(): """ from ddtrace import config from ddtrace import patch +from ddtrace import tracer import mariadb patch(mariadb=True) from tests.contrib.config import MARIADB_CONFIG @@ -143,6 +144,7 @@ def testcase(): cursor.execute("SELECT 1") rows = cursor.fetchall() assert len(rows) == 1 +tracer.shutdown() """, env={service_env_key: service_env_value}, ) From ff54feb81a329e2598a9fe1179b2bf3c69534ec5 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Mon, 19 Jul 2021 12:16:52 -0600 Subject: [PATCH 49/58] changing test case to pass in CI --- tests/contrib/mariadb/test_mariadb.py | 46 +++++++++++++++++---------- 1 file changed, 30 insertions(+), 16 deletions(-) diff --git a/tests/contrib/mariadb/test_mariadb.py b/tests/contrib/mariadb/test_mariadb.py index 7fa9b301317..138923d1590 100644 --- a/tests/contrib/mariadb/test_mariadb.py +++ b/tests/contrib/mariadb/test_mariadb.py @@ -114,24 +114,14 @@ def test_analytics_default(connection, tracer): span = spans[0] assert span.get_metric(ANALYTICS_SAMPLE_RATE_KEY) is None - -@pytest.mark.parametrize( - "service_env_key,service_env_value", [("DD_SERVICE", "mysvc"), ("DD_MARIADB_SERVICE", "mysvc")] -) -def test_user_specified_service_snapshot(run_python_code_in_subprocess, service_env_key, service_env_value): +@snapshot(async_mode=False) +def test_user_specified_dd_service_snapshot(run_python_code_in_subprocess): """ When a user specifies a service for the app The mariadb integration should not use it. """ - @snapshot( - async_mode=False, - token_override="tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_{}_{}".format( - service_env_key, service_env_value - ), - ) - def testcase(): - out, err, status, pid = run_python_code_in_subprocess( + out, err, status, pid = run_python_code_in_subprocess( """ from ddtrace import config from ddtrace import patch @@ -146,11 +136,35 @@ def testcase(): assert len(rows) == 1 tracer.shutdown() """, - env={service_env_key: service_env_value}, + env={"DD_SERVICE": "mysvc"}, ) - assert status == 0, err + assert status == 0, err - testcase() +@snapshot(async_mode=False) +def test_user_specified_dd_mariadb_service_snapshot(run_python_code_in_subprocess): + """ + When a user specifies a service for the app + The mariadb integration should not use it. + """ + + out, err, status, pid = run_python_code_in_subprocess( + """ +from ddtrace import config +from ddtrace import patch +from ddtrace import tracer +import mariadb +patch(mariadb=True) +from tests.contrib.config import MARIADB_CONFIG +connection = mariadb.connect(**MARIADB_CONFIG) +cursor = connection.cursor() +cursor.execute("SELECT 1") +rows = cursor.fetchall() +assert len(rows) == 1 +tracer.shutdown() +""", + env={"DD_MARIADB_SERVICE": "mysvc"}, + ) + assert status == 0, err @snapshot(include_tracer=True) From 8ff94b4cf76cda92eca5cb557937cbe2202f3121 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Mon, 19 Jul 2021 12:21:29 -0600 Subject: [PATCH 50/58] formatting --- tests/contrib/mariadb/test_mariadb.py | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/tests/contrib/mariadb/test_mariadb.py b/tests/contrib/mariadb/test_mariadb.py index 138923d1590..bad6b4d5ccc 100644 --- a/tests/contrib/mariadb/test_mariadb.py +++ b/tests/contrib/mariadb/test_mariadb.py @@ -114,6 +114,7 @@ def test_analytics_default(connection, tracer): span = spans[0] assert span.get_metric(ANALYTICS_SAMPLE_RATE_KEY) is None + @snapshot(async_mode=False) def test_user_specified_dd_service_snapshot(run_python_code_in_subprocess): """ @@ -122,7 +123,7 @@ def test_user_specified_dd_service_snapshot(run_python_code_in_subprocess): """ out, err, status, pid = run_python_code_in_subprocess( - """ + """ from ddtrace import config from ddtrace import patch from ddtrace import tracer @@ -136,10 +137,11 @@ def test_user_specified_dd_service_snapshot(run_python_code_in_subprocess): assert len(rows) == 1 tracer.shutdown() """, - env={"DD_SERVICE": "mysvc"}, - ) + env={"DD_SERVICE": "mysvc"}, + ) assert status == 0, err + @snapshot(async_mode=False) def test_user_specified_dd_mariadb_service_snapshot(run_python_code_in_subprocess): """ @@ -148,7 +150,7 @@ def test_user_specified_dd_mariadb_service_snapshot(run_python_code_in_subproces """ out, err, status, pid = run_python_code_in_subprocess( - """ + """ from ddtrace import config from ddtrace import patch from ddtrace import tracer @@ -162,8 +164,8 @@ def test_user_specified_dd_mariadb_service_snapshot(run_python_code_in_subproces assert len(rows) == 1 tracer.shutdown() """, - env={"DD_MARIADB_SERVICE": "mysvc"}, - ) + env={"DD_MARIADB_SERVICE": "mysvc"}, + ) assert status == 0, err From 5d53d3924c0ad0b132ff9c8aea801a72551a974e Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Mon, 19 Jul 2021 12:30:37 -0600 Subject: [PATCH 51/58] Update ddtrace/contrib/mariadb/__init__.py Co-authored-by: Kyle Verhoog --- ddtrace/contrib/mariadb/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ddtrace/contrib/mariadb/__init__.py b/ddtrace/contrib/mariadb/__init__.py index 68bbde1a56e..4c138e177b7 100644 --- a/ddtrace/contrib/mariadb/__init__.py +++ b/ddtrace/contrib/mariadb/__init__.py @@ -1,6 +1,6 @@ """ The MariaDB integration instruments the -:ref:`MariaDB library` to trace queries. +`MariaDB library`_ to trace queries. Enabling From cc74fc0d5142a932f706d5e6aaedf12fdf58896d Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Mon, 19 Jul 2021 12:30:48 -0600 Subject: [PATCH 52/58] Update ddtrace/contrib/mariadb/__init__.py Co-authored-by: Kyle Verhoog --- ddtrace/contrib/mariadb/__init__.py | 1 - 1 file changed, 1 deletion(-) diff --git a/ddtrace/contrib/mariadb/__init__.py b/ddtrace/contrib/mariadb/__init__.py index 4c138e177b7..d43a45ff1ef 100644 --- a/ddtrace/contrib/mariadb/__init__.py +++ b/ddtrace/contrib/mariadb/__init__.py @@ -51,7 +51,6 @@ cursor = conn.cursor() cursor.execute("SELECT 6*7 AS the_answer;") -https://mariadb-corporation.github.io/mariadb-connector-python/usage.html """ from ...utils.importlib import require_modules From 83d5e0142018418ee0e6227d5361343c047d5519 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Mon, 19 Jul 2021 14:21:18 -0600 Subject: [PATCH 53/58] snapshots --- ...adb.test_analytics_with_rate_snapshot.snap | 8 +++---- ....test_analytics_without_rate_snapshot.snap | 8 +++---- ...adb.test_mariadb.test_commit_snapshot.snap | 8 +++---- ...adb.test_query_many_fetchall_snapshot.snap | 24 +++++++++---------- ...test_mariadb.test_query_proc_snapshot.snap | 8 +++---- ...y_with_several_rows_fetchall_snapshot.snap | 16 ++++++------- ...test_query_with_several_rows_snapshot.snap | 8 +++---- ....test_simple_malformed_query_snapshot.snap | 8 +++---- ...b.test_simple_query_fetchall_snapshot.snap | 16 ++++++------- ...st_mariadb.test_simple_query_snapshot.snap | 8 +++---- ...pecified_dd_mariadb_service_snapshot.snap} | 8 +++---- ...t_user_specified_dd_service_snapshot.snap} | 8 +++---- 12 files changed, 64 insertions(+), 64 deletions(-) rename tests/snapshots/{tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_MARIADB_SERVICE_mysvc.snap => tests.contrib.mariadb.test_mariadb.test_user_specified_dd_mariadb_service_snapshot.snap} (76%) rename tests/snapshots/{tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_SERVICE_mysvc.snap => tests.contrib.mariadb.test_mariadb.test_user_specified_dd_service_snapshot.snap} (76%) diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_analytics_with_rate_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_analytics_with_rate_snapshot.snap index 64b65257f0b..6749529ce0c 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_analytics_with_rate_snapshot.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_analytics_with_rate_snapshot.snap @@ -6,9 +6,9 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626232692638571500 - "duration" 638700 - "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" + "start" 1626718453548365000 + "duration" 980000 + "meta" {"runtime-id" "0cbfb96da3ee4e86be3cf3b8a4004f86" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} @@ -16,7 +16,7 @@ "_dd.measured" 1 "_dd1.sr.eausr" 0.5 "_sampling_priority_v1" 1 - "system.pid" 12385 + "system.pid" 1502 "_dd.tracer_kr" 1.0 "sql.rows" 0 "db.rowcount" 0 diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_analytics_without_rate_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_analytics_without_rate_snapshot.snap index 166ed22be8f..d5a8d6b66b1 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_analytics_without_rate_snapshot.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_analytics_without_rate_snapshot.snap @@ -6,9 +6,9 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626232692662242600 - "duration" 636100 - "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" + "start" 1626718453593771000 + "duration" 1124000 + "meta" {"runtime-id" "0cbfb96da3ee4e86be3cf3b8a4004f86" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} @@ -16,7 +16,7 @@ "_dd.measured" 1 "_dd1.sr.eausr" 1.0 "_sampling_priority_v1" 1 - "system.pid" 12385 + "system.pid" 1502 "_dd.tracer_kr" 1.0 "sql.rows" 0 "db.rowcount" 0 diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_commit_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_commit_snapshot.snap index fec902b9d6f..ec1505c0f52 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_commit_snapshot.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_commit_snapshot.snap @@ -5,14 +5,14 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626220628211178100 - "duration" 952600 - "meta" {"runtime-id" "0d2b28a27ae249f88ff7ed45801df80a" + "start" 1626718453452681000 + "duration" 1324000 + "meta" {"runtime-id" "0cbfb96da3ee4e86be3cf3b8a4004f86" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_sampling_priority_v1" 1 - "system.pid" 11226 + "system.pid" 1502 "out.port" 3306 "_dd.tracer_kr" 1.0}}]] diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_many_fetchall_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_many_fetchall_snapshot.snap index a7f70689da7..f7f16dca4c6 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_many_fetchall_snapshot.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_many_fetchall_snapshot.snap @@ -6,9 +6,9 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626232692394915800 - "duration" 1561300 - "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" + "start" 1626718453407952000 + "duration" 1705000 + "meta" {"runtime-id" "0cbfb96da3ee4e86be3cf3b8a4004f86" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test" @@ -16,7 +16,7 @@ "metrics" {"_dd.agent_psr" 1.0 "_dd.measured" 1 "_sampling_priority_v1" 1 - "system.pid" 12385 + "system.pid" 1502 "out.port" 3306 "db.rowcount" 2 "sql.rows" 2 @@ -29,16 +29,16 @@ "span_id" 0 "trace_id" 1 "parent_id" nil - "start" 1626232692397364100 - "duration" 1868900 - "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" + "start" 1626718453410309000 + "duration" 1858000 + "meta" {"runtime-id" "0cbfb96da3ee4e86be3cf3b8a4004f86" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_dd.measured" 1 "_sampling_priority_v1" 1 - "system.pid" 12385 + "system.pid" 1502 "out.port" 3306 "db.rowcount" 0 "sql.rows" 0 @@ -51,15 +51,15 @@ "span_id" 0 "trace_id" 2 "parent_id" nil - "start" 1626232692399424200 - "duration" 75000 - "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" + "start" 1626718453412328000 + "duration" 331000 + "meta" {"runtime-id" "0cbfb96da3ee4e86be3cf3b8a4004f86" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_sampling_priority_v1" 1 - "system.pid" 12385 + "system.pid" 1502 "out.port" 3306 "db.rowcount" 2 "sql.rows" 2 diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_proc_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_proc_snapshot.snap index beacd474d24..2700354fb46 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_proc_snapshot.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_proc_snapshot.snap @@ -6,16 +6,16 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626232692612789400 - "duration" 1446200 - "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" + "start" 1626718453505520000 + "duration" 1564000 + "meta" {"runtime-id" "0cbfb96da3ee4e86be3cf3b8a4004f86" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_dd.measured" 1 "_sampling_priority_v1" 1 - "system.pid" 12385 + "system.pid" 1502 "out.port" 3306 "db.rowcount" 0 "sql.rows" 0 diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_with_several_rows_fetchall_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_with_several_rows_fetchall_snapshot.snap index 5bd0194203b..81fc8d0b3c5 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_with_several_rows_fetchall_snapshot.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_with_several_rows_fetchall_snapshot.snap @@ -6,16 +6,16 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626232692364655200 - "duration" 640800 - "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" + "start" 1626718453355264000 + "duration" 1786000 + "meta" {"runtime-id" "0cbfb96da3ee4e86be3cf3b8a4004f86" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_dd.measured" 1 "_sampling_priority_v1" 1 - "system.pid" 12385 + "system.pid" 1502 "out.port" 3306 "db.rowcount" 0 "sql.rows" 0 @@ -28,15 +28,15 @@ "span_id" 0 "trace_id" 1 "parent_id" nil - "start" 1626232692365859200 - "duration" 70000 - "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" + "start" 1626718453359605000 + "duration" 113000 + "meta" {"runtime-id" "0cbfb96da3ee4e86be3cf3b8a4004f86" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_sampling_priority_v1" 1 - "system.pid" 12385 + "system.pid" 1502 "out.port" 3306 "db.rowcount" 3 "sql.rows" 3 diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_with_several_rows_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_with_several_rows_snapshot.snap index 3c9efc5be5a..d61cef80afa 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_with_several_rows_snapshot.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_query_with_several_rows_snapshot.snap @@ -6,16 +6,16 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626232692342101400 - "duration" 2084200 - "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" + "start" 1626718453319829000 + "duration" 1217000 + "meta" {"runtime-id" "0cbfb96da3ee4e86be3cf3b8a4004f86" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_dd.measured" 1 "_sampling_priority_v1" 1 - "system.pid" 12385 + "system.pid" 1502 "out.port" 3306 "db.rowcount" 0 "sql.rows" 0 diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_malformed_query_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_malformed_query_snapshot.snap index aa3a2a1612b..13895395297 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_malformed_query_snapshot.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_malformed_query_snapshot.snap @@ -6,9 +6,9 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626232692284132700 - "duration" 2013100 - "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" + "start" 1626718453234358000 + "duration" 3750000 + "meta" {"runtime-id" "0cbfb96da3ee4e86be3cf3b8a4004f86" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test" @@ -18,7 +18,7 @@ "metrics" {"_dd.agent_psr" 1.0 "_dd.measured" 1 "_sampling_priority_v1" 1 - "system.pid" 12385 + "system.pid" 1502 "out.port" 3306 "db.rowcount" -1 "_dd.tracer_kr" 1.0}}]] diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_fetchall_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_fetchall_snapshot.snap index 534532c5970..0be28f3f7e8 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_fetchall_snapshot.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_fetchall_snapshot.snap @@ -6,16 +6,16 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626232692316370400 - "duration" 911600 - "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" + "start" 1626718453278969000 + "duration" 1180000 + "meta" {"runtime-id" "0cbfb96da3ee4e86be3cf3b8a4004f86" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_dd.measured" 1 "_sampling_priority_v1" 1 - "system.pid" 12385 + "system.pid" 1502 "out.port" 3306 "db.rowcount" 0 "sql.rows" 0 @@ -28,15 +28,15 @@ "span_id" 0 "trace_id" 1 "parent_id" nil - "start" 1626232692317850500 - "duration" 72100 - "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" + "start" 1626718453281057000 + "duration" 156000 + "meta" {"runtime-id" "0cbfb96da3ee4e86be3cf3b8a4004f86" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_sampling_priority_v1" 1 - "system.pid" 12385 + "system.pid" 1502 "out.port" 3306 "db.rowcount" 1 "sql.rows" 1 diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_snapshot.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_snapshot.snap index fa732f64cd7..475c473f12c 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_snapshot.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_simple_query_snapshot.snap @@ -6,16 +6,16 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626232692262017600 - "duration" 786800 - "meta" {"runtime-id" "a0baeb301d0f450681538923d7de700f" + "start" 1626718453185258000 + "duration" 824000 + "meta" {"runtime-id" "0cbfb96da3ee4e86be3cf3b8a4004f86" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_dd.measured" 1 "_sampling_priority_v1" 1 - "system.pid" 12385 + "system.pid" 1502 "out.port" 3306 "db.rowcount" 0 "sql.rows" 0 diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_MARIADB_SERVICE_mysvc.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_dd_mariadb_service_snapshot.snap similarity index 76% rename from tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_MARIADB_SERVICE_mysvc.snap rename to tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_dd_mariadb_service_snapshot.snap index ca023c730d3..65417795c3d 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_MARIADB_SERVICE_mysvc.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_dd_mariadb_service_snapshot.snap @@ -6,16 +6,16 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626232692202090900 - "duration" 581600 - "meta" {"runtime-id" "9eb01c32305f409999b99721fc511d80" + "start" 1626718453097564000 + "duration" 1121000 + "meta" {"runtime-id" "659d2043e2704c97ac93280150cb1ce6" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_dd.measured" 1 "_sampling_priority_v1" 1 - "system.pid" 12392 + "system.pid" 1511 "out.port" 3306 "db.rowcount" 0 "sql.rows" 0 diff --git a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_SERVICE_mysvc.snap b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_dd_service_snapshot.snap similarity index 76% rename from tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_SERVICE_mysvc.snap rename to tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_dd_service_snapshot.snap index ec05b8c8e7b..6f457179fbe 100644 --- a/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_service_snapshot_DD_SERVICE_mysvc.snap +++ b/tests/snapshots/tests.contrib.mariadb.test_mariadb.test_user_specified_dd_service_snapshot.snap @@ -6,16 +6,16 @@ "span_id" 0 "trace_id" 0 "parent_id" nil - "start" 1626232691457749100 - "duration" 788000 - "meta" {"runtime-id" "cee61bc6db3640dfa9b933cef309c5d9" + "start" 1626718452059170000 + "duration" 1491000 + "meta" {"runtime-id" "cf25a26f85404c2fa6542978216544cd" "out.host" "127.0.0.1" "db.user" "test" "db.name" "test"} "metrics" {"_dd.agent_psr" 1.0 "_dd.measured" 1 "_sampling_priority_v1" 1 - "system.pid" 12389 + "system.pid" 1508 "out.port" 3306 "db.rowcount" 0 "sql.rows" 0 From 3cd48936774e3e5376de322d9407cdc70801b6b5 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Tue, 20 Jul 2021 09:48:24 -0600 Subject: [PATCH 54/58] updating tests so connection closes on each --- tests/contrib/mariadb/test_mariadb.py | 152 +++++++++++++------------- 1 file changed, 76 insertions(+), 76 deletions(-) diff --git a/tests/contrib/mariadb/test_mariadb.py b/tests/contrib/mariadb/test_mariadb.py index bad6b4d5ccc..172188b8c2d 100644 --- a/tests/contrib/mariadb/test_mariadb.py +++ b/tests/contrib/mariadb/test_mariadb.py @@ -171,45 +171,34 @@ def test_user_specified_dd_mariadb_service_snapshot(run_python_code_in_subproces @snapshot(include_tracer=True) def test_simple_query_snapshot(tracer): - connection = get_connection(tracer) - cursor = connection.cursor() - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 + with get_connection(tracer) as connection: + cursor = connection.cursor() + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 @snapshot(include_tracer=True, ignores=["meta.error.stack"]) def test_simple_malformed_query_snapshot(tracer): - connection = get_connection(tracer) - cursor = connection.cursor() - with pytest.raises(mariadb.ProgrammingError): - cursor.execute("SELEC 1") + with get_connection(tracer) as connection: + cursor = connection.cursor() + with pytest.raises(mariadb.ProgrammingError): + cursor.execute("SELEC 1") @snapshot(include_tracer=True) def test_simple_query_fetchall_snapshot(tracer): with override_config("mariadb", dict(trace_fetch_methods=True)): - connection = get_connection(tracer) - cursor = connection.cursor() - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 + with get_connection(tracer) as connection: + cursor = connection.cursor() + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 @snapshot(include_tracer=True) def test_query_with_several_rows_snapshot(tracer): - connection = get_connection(tracer) - cursor = connection.cursor() - query = "SELECT n FROM (SELECT 42 n UNION SELECT 421 UNION SELECT 4210) m" - cursor.execute(query) - rows = cursor.fetchall() - assert len(rows) == 3 - - -@snapshot(include_tracer=True) -def test_query_with_several_rows_fetchall_snapshot(tracer): - with override_config("mariadb", dict(trace_fetch_methods=True)): - connection = get_connection(tracer) + with get_connection(tracer) as connection: cursor = connection.cursor() query = "SELECT n FROM (SELECT 42 n UNION SELECT 421 UNION SELECT 4210) m" cursor.execute(query) @@ -218,76 +207,87 @@ def test_query_with_several_rows_fetchall_snapshot(tracer): @snapshot(include_tracer=True) -def test_query_many_fetchall_snapshot(tracer): +def test_query_with_several_rows_fetchall_snapshot(tracer): with override_config("mariadb", dict(trace_fetch_methods=True)): - connection = get_connection(tracer) + with get_connection(tracer) as connection: + cursor = connection.cursor() + query = "SELECT n FROM (SELECT 42 n UNION SELECT 421 UNION SELECT 4210) m" + cursor.execute(query) + rows = cursor.fetchall() + assert len(rows) == 3 - # tests that the executemany method is correctly wrapped. - tracer.enabled = False - cursor = connection.cursor() - cursor.execute( - """ - create table if not exists dummy ( - dummy_key VARCHAR(32) PRIMARY KEY, - dummy_value TEXT NOT NULL)""" - ) - tracer.enabled = True +@snapshot(include_tracer=True) +def test_query_many_fetchall_snapshot(tracer): + with override_config("mariadb", dict(trace_fetch_methods=True)): + with get_connection(tracer) as connection: - stmt = "INSERT INTO dummy (dummy_key, dummy_value) VALUES (%s, %s)" - data = [ - ("foo", "this is foo"), - ("bar", "this is bar"), - ] - cursor.executemany(stmt, data) - query = "SELECT dummy_key, dummy_value FROM dummy ORDER BY dummy_key" - cursor.execute(query) - rows = cursor.fetchall() - assert len(rows) == 2 + # tests that the executemany method is correctly wrapped. + tracer.enabled = False + cursor = connection.cursor() + + cursor.execute( + """ + create table if not exists dummy ( + dummy_key VARCHAR(32) PRIMARY KEY, + dummy_value TEXT NOT NULL)""" + ) + tracer.enabled = True + + stmt = "INSERT INTO dummy (dummy_key, dummy_value) VALUES (%s, %s)" + data = [ + ("foo", "this is foo"), + ("bar", "this is bar"), + ] + cursor.executemany(stmt, data) + query = "SELECT dummy_key, dummy_value FROM dummy ORDER BY dummy_key" + cursor.execute(query) + rows = cursor.fetchall() + assert len(rows) == 2 @snapshot(include_tracer=True) def test_commit_snapshot(tracer): - connection = get_connection(tracer) - connection.commit() + with get_connection(tracer) as connection: + connection.commit() @snapshot(include_tracer=True) def test_query_proc_snapshot(tracer): - connection = get_connection(tracer) - # create a procedure - tracer.enabled = False - cursor = connection.cursor() - cursor.execute("DROP PROCEDURE IF EXISTS sp_sum") - cursor.execute( - """ - CREATE PROCEDURE sp_sum (IN p1 INTEGER, IN p2 INTEGER, OUT p3 INTEGER) - BEGIN - SET p3 := p1 + p2; - END;""" - ) + with get_connection(tracer) as connection: + # create a procedure + tracer.enabled = False + cursor = connection.cursor() + cursor.execute("DROP PROCEDURE IF EXISTS sp_sum") + cursor.execute( + """ + CREATE PROCEDURE sp_sum (IN p1 INTEGER, IN p2 INTEGER, OUT p3 INTEGER) + BEGIN + SET p3 := p1 + p2; + END;""" + ) - tracer.enabled = True - proc = "sp_sum" - data = (40, 2, None) - cursor.callproc(proc, data) + tracer.enabled = True + proc = "sp_sum" + data = (40, 2, None) + cursor.callproc(proc, data) @snapshot(include_tracer=True) def test_analytics_with_rate_snapshot(tracer): with override_config("mariadb", dict(analytics_enabled=True, analytics_sample_rate=0.5)): - connection = get_connection(tracer) - cursor = connection.cursor() - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 + with get_connection(tracer) as connection: + cursor = connection.cursor() + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 @snapshot(include_tracer=True) def test_analytics_without_rate_snapshot(tracer): with override_config("mariadb", dict(analytics_enabled=True)): - connection = get_connection(tracer) - cursor = connection.cursor() - cursor.execute("SELECT 1") - rows = cursor.fetchall() - assert len(rows) == 1 + with get_connection(tracer) as connection: + cursor = connection.cursor() + cursor.execute("SELECT 1") + rows = cursor.fetchall() + assert len(rows) == 1 From 82f47fc0cd0ad03a0d672857994b185cc4d0414a Mon Sep 17 00:00:00 2001 From: Kyle Verhoog Date: Tue, 20 Jul 2021 13:43:44 -0400 Subject: [PATCH 55/58] Extend environment instead of replacing it --- tests/contrib/mariadb/test_mariadb.py | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/tests/contrib/mariadb/test_mariadb.py b/tests/contrib/mariadb/test_mariadb.py index 172188b8c2d..6509fc66a61 100644 --- a/tests/contrib/mariadb/test_mariadb.py +++ b/tests/contrib/mariadb/test_mariadb.py @@ -1,3 +1,5 @@ +import os + import mariadb import pytest @@ -121,7 +123,8 @@ def test_user_specified_dd_service_snapshot(run_python_code_in_subprocess): When a user specifies a service for the app The mariadb integration should not use it. """ - + env = os.environ.copy() + env["DD_SERVICE"] = "mysvc" out, err, status, pid = run_python_code_in_subprocess( """ from ddtrace import config @@ -137,7 +140,7 @@ def test_user_specified_dd_service_snapshot(run_python_code_in_subprocess): assert len(rows) == 1 tracer.shutdown() """, - env={"DD_SERVICE": "mysvc"}, + env=env, ) assert status == 0, err @@ -149,6 +152,8 @@ def test_user_specified_dd_mariadb_service_snapshot(run_python_code_in_subproces The mariadb integration should not use it. """ + env = os.environ.copy() + env["DD_MARIADB_SERVICE"] = "mysvc" out, err, status, pid = run_python_code_in_subprocess( """ from ddtrace import config @@ -164,7 +169,7 @@ def test_user_specified_dd_mariadb_service_snapshot(run_python_code_in_subproces assert len(rows) == 1 tracer.shutdown() """, - env={"DD_MARIADB_SERVICE": "mysvc"}, + env=env, ) assert status == 0, err @@ -222,7 +227,7 @@ def test_query_many_fetchall_snapshot(tracer): with override_config("mariadb", dict(trace_fetch_methods=True)): with get_connection(tracer) as connection: - # tests that the executemany method is correctly wrapped. + # tests that the executemany method is correctly wrapped. tracer.enabled = False cursor = connection.cursor() @@ -254,7 +259,7 @@ def test_commit_snapshot(tracer): @snapshot(include_tracer=True) def test_query_proc_snapshot(tracer): - with get_connection(tracer) as connection: + with get_connection(tracer) as connection: # create a procedure tracer.enabled = False cursor = connection.cursor() From e567e5fc0029dae95edd730f58c2b54e81795e34 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Tue, 20 Jul 2021 11:54:44 -0600 Subject: [PATCH 56/58] fix formatting and refactor a bit in tests --- Dockerfile.buster | 4 +-- ddtrace/contrib/mariadb/__init__.py | 2 +- tests/contrib/mariadb/test_mariadb.py | 40 ++++++++++----------------- 3 files changed, 17 insertions(+), 29 deletions(-) diff --git a/Dockerfile.buster b/Dockerfile.buster index 646f3e6918e..4e9a349ef5b 100644 --- a/Dockerfile.buster +++ b/Dockerfile.buster @@ -56,9 +56,7 @@ RUN \ && apt-get install -y --no-install-recommends nodejs \ && apt-get install -y libmariadb3 \ # Cleaning up apt cache space - && rm -rf /var/lib/apt/lists/* \ - - + && rm -rf /var/lib/apt/lists/* # Configure PATH environment for pyenv diff --git a/ddtrace/contrib/mariadb/__init__.py b/ddtrace/contrib/mariadb/__init__.py index d43a45ff1ef..f1803653de1 100644 --- a/ddtrace/contrib/mariadb/__init__.py +++ b/ddtrace/contrib/mariadb/__init__.py @@ -1,6 +1,6 @@ """ The MariaDB integration instruments the -`MariaDB library`_ to trace queries. +`MariaDB library `_ to trace queries. Enabling diff --git a/tests/contrib/mariadb/test_mariadb.py b/tests/contrib/mariadb/test_mariadb.py index 6509fc66a61..4e7f040036a 100644 --- a/tests/contrib/mariadb/test_mariadb.py +++ b/tests/contrib/mariadb/test_mariadb.py @@ -117,16 +117,7 @@ def test_analytics_default(connection, tracer): assert span.get_metric(ANALYTICS_SAMPLE_RATE_KEY) is None -@snapshot(async_mode=False) -def test_user_specified_dd_service_snapshot(run_python_code_in_subprocess): - """ - When a user specifies a service for the app - The mariadb integration should not use it. - """ - env = os.environ.copy() - env["DD_SERVICE"] = "mysvc" - out, err, status, pid = run_python_code_in_subprocess( - """ +test_user_specified_code = """ from ddtrace import config from ddtrace import patch from ddtrace import tracer @@ -139,7 +130,19 @@ def test_user_specified_dd_service_snapshot(run_python_code_in_subprocess): rows = cursor.fetchall() assert len(rows) == 1 tracer.shutdown() -""", +""" + + +@snapshot(async_mode=False) +def test_user_specified_dd_service_snapshot(run_python_code_in_subprocess): + """ + When a user specifies a service for the app + The mariadb integration should not use it. + """ + env = os.environ.copy() + env["DD_SERVICE"] = "mysvc" + out, err, status, pid = run_python_code_in_subprocess( + test_user_specified_code, env=env, ) assert status == 0, err @@ -155,20 +158,7 @@ def test_user_specified_dd_mariadb_service_snapshot(run_python_code_in_subproces env = os.environ.copy() env["DD_MARIADB_SERVICE"] = "mysvc" out, err, status, pid = run_python_code_in_subprocess( - """ -from ddtrace import config -from ddtrace import patch -from ddtrace import tracer -import mariadb -patch(mariadb=True) -from tests.contrib.config import MARIADB_CONFIG -connection = mariadb.connect(**MARIADB_CONFIG) -cursor = connection.cursor() -cursor.execute("SELECT 1") -rows = cursor.fetchall() -assert len(rows) == 1 -tracer.shutdown() -""", + test_user_specified_code, env=env, ) assert status == 0, err From 64dfb74b4d7220b41169c6f04636741a4bbccbc2 Mon Sep 17 00:00:00 2001 From: Zachary Groves <32471391+ZStriker19@users.noreply.github.com> Date: Tue, 20 Jul 2021 12:39:56 -0600 Subject: [PATCH 57/58] Update ddtrace/contrib/mariadb/__init__.py Co-authored-by: Kyle Verhoog --- ddtrace/contrib/mariadb/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ddtrace/contrib/mariadb/__init__.py b/ddtrace/contrib/mariadb/__init__.py index d43a45ff1ef..f1803653de1 100644 --- a/ddtrace/contrib/mariadb/__init__.py +++ b/ddtrace/contrib/mariadb/__init__.py @@ -1,6 +1,6 @@ """ The MariaDB integration instruments the -`MariaDB library`_ to trace queries. +`MariaDB library `_ to trace queries. Enabling From c373a381633b78d9090ae05da50e6a1d174875c7 Mon Sep 17 00:00:00 2001 From: ZStriker19 Date: Tue, 20 Jul 2021 20:47:28 -0600 Subject: [PATCH 58/58] formatting --- Dockerfile.buster | 2 -- 1 file changed, 2 deletions(-) diff --git a/Dockerfile.buster b/Dockerfile.buster index 4e9a349ef5b..fb8e935851e 100644 --- a/Dockerfile.buster +++ b/Dockerfile.buster @@ -57,8 +57,6 @@ RUN \ && apt-get install -y libmariadb3 \ # Cleaning up apt cache space && rm -rf /var/lib/apt/lists/* - - # Configure PATH environment for pyenv ENV PYENV_ROOT /root/.pyenv ENV PATH ${PYENV_ROOT}/shims:${PYENV_ROOT}/bin:$PATH