def test_contextmanager_connection(self):
conn, tracer = self._get_conn_tracer()
with conn as c:
if MySQLdb.version_info < (2, 0):
cursor = c
else:
cursor = c.cursor()
rowcount = cursor.execute("SELECT 1")
assert rowcount == 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("mysql", 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.get_tags(),
{
"out.host": u"127.0.0.1",
"db.name": u"test",
"db.user": u"test",
},
)
assert spans[1].name == "mysql.query.fetchall"
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 == "pymysql"
assert dd_span.name == "pymysql.query"
assert dd_span.span_type == "sql"
assert dd_span.error == 0
assert dd_span.get_metric("out.port") == MYSQL_CONFIG.get("port")
meta = {}
meta.update(self.DB_INFO)
assert_dict_issuperset(dd_span.meta, meta)
assert fetch_span.name == "pymysql.query.fetchall"
def test_simple_query_with_positional_args(self):
conn, tracer = self._get_conn_tracer_with_positional_args()
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_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.get_tags(),
{
"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()
def test_simple_cache_clear(self):
self.cache.clear()
spans = self.get_spans()
self.assertEqual(len(spans), 1)
span = spans[0]
assert_is_measured(span)
self.assertEqual(span.service, self.SERVICE)
self.assertEqual(span.resource, "clear")
self.assertEqual(span.name, "flask_cache.cmd")
self.assertEqual(span.span_type, "cache")
self.assertEqual(span.error, 0)
expected_meta = {
"flask_cache.backend": "simple",
}
assert_dict_issuperset(span.meta, expected_meta)
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
# resulted p3 isn't stored on output[2], we need to fetch it with select
# http://mysqlclient.readthedocs.io/user_guide.html#cursor-objects
cursor.execute("SELECT @_sp_sum_2;")
assert cursor.fetchone()[0] == 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 next to the last closed span to be our proc.
span = spans[-2]
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_cache_delete_many(self):
self.cache.delete_many("complex_operation", "another_complex_op")
spans = self.get_spans()
self.assertEqual(len(spans), 1)
span = spans[0]
assert_is_measured(span)
self.assertEqual(span.service, self.SERVICE)
self.assertEqual(span.resource, "delete_many")
self.assertEqual(span.name, "flask_cache.cmd")
self.assertEqual(span.span_type, "cache")
self.assertEqual(span.error, 0)
expected_meta = {
"flask_cache.key": "['complex_operation', 'another_complex_op']",
"flask_cache.backend": "simple",
}
assert_dict_issuperset(span.meta, expected_meta)
def test_simple_cache_add(self):
self.cache.add(u"á_complex_number", 50)
spans = self.get_spans()
self.assertEqual(len(spans), 1)
span = spans[0]
assert_is_measured(span)
self.assertEqual(span.service, self.SERVICE)
self.assertEqual(span.resource, "add")
self.assertEqual(span.name, "flask_cache.cmd")
self.assertEqual(span.span_type, "cache")
self.assertEqual(span.error, 0)
expected_meta = {
"flask_cache.key": u"á_complex_number",
"flask_cache.backend": "simple",
}
assert_dict_issuperset(span.get_tags(), expected_meta)
def test_simple_cache_get_many(self):
self.cache.get_many("first_complex_op", "second_complex_op")
spans = self.get_spans()
self.assertEqual(len(spans), 1)
span = spans[0]
assert_is_measured(span)
self.assertEqual(span.service, self.SERVICE)
self.assertEqual(span.resource, "get_many")
self.assertEqual(span.name, "flask_cache.cmd")
self.assertEqual(span.span_type, "cache")
self.assertEqual(span.error, 0)
expected_meta = {
"flask_cache.key": "['first_complex_op', 'second_complex_op']",
"flask_cache.backend": "simple",
}
assert_dict_issuperset(span.meta, expected_meta)
def test_simple_cache_set(self):
self.cache.set(u"á_complex_operation", u"with_á_value\nin two lines")
spans = self.get_spans()
self.assertEqual(len(spans), 1)
span = spans[0]
assert_is_measured(span)
self.assertEqual(span.service, self.SERVICE)
self.assertEqual(span.resource, "set")
self.assertEqual(span.name, "flask_cache.cmd")
self.assertEqual(span.span_type, "cache")
self.assertEqual(span.error, 0)
expected_meta = {
"flask_cache.key": u"á_complex_operation",
"flask_cache.backend": "simple",
}
assert_dict_issuperset(span.meta, expected_meta)
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)
# spans[len(spans) - 2]
cursor.callproc(proc, data)
# spans[len(spans) - 1]
cursor.execute("""
SELECT @_sp_sum_0, @_sp_sum_1, @_sp_sum_2
""")
output = cursor.fetchone()
assert len(output) == 3
assert output[2] == 42
spans = tracer.pop()
assert spans, spans
# number of spans depends on PyMySQL 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) - 2]
assert_is_measured(span)
assert span.service == "pymysql"
assert span.name == "pymysql.query"
assert span.span_type == "sql"
assert span.error == 0
assert span.get_metric("out.port") == MYSQL_CONFIG.get("port")
meta = {}
meta.update(self.DB_INFO)
assert_dict_issuperset(span.meta, meta)
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_patch_unpatch(self):
unpatch()
# assert we start unpatched
conn = pymysql.connect(**MYSQL_CONFIG)
assert not Pin.get_from(conn)
conn.close()
patch()
try:
conn = pymysql.connect(**MYSQL_CONFIG)
pin = Pin.get_from(conn)
assert pin
pin.clone(tracer=self.tracer).onto(conn)
assert not conn._closed
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 == "pymysql"
assert span.name == "pymysql.query"
assert span.span_type == "sql"
assert span.error == 0
assert span.get_metric("out.port") == MYSQL_CONFIG.get("port")
meta = {}
meta.update(self.DB_INFO)
assert_dict_issuperset(span.meta, meta)
finally:
unpatch()
# assert we finish unpatched
conn = pymysql.connect(**MYSQL_CONFIG)
assert not Pin.get_from(conn)
conn.close()
patch()
def test_simple_query_ot_fetchall(self):
"""OpenTracing version of test_simple_query."""
with self.override_config("mysql", 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.get_tags(),
{
"out.host": u"127.0.0.1",
"db.name": u"test",
"db.user": u"test",
},
)
assert fetch_span.name == "mysql.query.fetchall"
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(self):
conn, tracer = self._get_conn_tracer()
cursor = conn.cursor()
# PyMySQL returns back the rowcount instead of a cursor
rowcount = cursor.execute("SELECT 1")
assert rowcount == 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 == "pymysql"
assert span.name == "pymysql.query"
assert span.span_type == "sql"
assert span.error == 0
assert span.get_metric("out.port") == MYSQL_CONFIG.get("port")
meta = {}
meta.update(self.DB_INFO)
assert_dict_issuperset(span.meta, meta)
def test_simple_cache_get_ot(self):
"""OpenTracing version of test_simple_cache_get."""
ot_tracer = init_tracer("my_svc", self.tracer)
# create the TracedCache instance for a Flask app
Cache = get_traced_cache(self.tracer, service=self.SERVICE)
app = Flask(__name__)
cache = Cache(app, config={"CACHE_TYPE": "simple"})
with ot_tracer.start_active_span("ot_span"):
cache.get(u"á_complex_operation")
spans = self.get_spans()
self.assertEqual(len(spans), 2)
ot_span, dd_span = spans
# confirm the parenting
self.assertIsNone(ot_span.parent_id)
self.assertEqual(dd_span.parent_id, ot_span.span_id)
self.assertEqual(ot_span.resource, "ot_span")
self.assertEqual(ot_span.service, "my_svc")
assert_is_measured(dd_span)
self.assertEqual(dd_span.service, self.SERVICE)
self.assertEqual(dd_span.resource, "get")
self.assertEqual(dd_span.name, "flask_cache.cmd")
self.assertEqual(dd_span.span_type, "cache")
self.assertEqual(dd_span.error, 0)
expected_meta = {
"flask_cache.key": u"á_complex_operation",
"flask_cache.backend": "simple",
}
assert_dict_issuperset(dd_span.meta, expected_meta)
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")
rows = cursor.fetchall()
assert len(rows) == 1
spans = tracer.pop()
assert len(spans) == 2
span = spans[0]
assert_is_measured(span)
assert span.service == "pymysql"
assert span.name == "pymysql.query"
assert span.span_type == "sql"
assert span.error == 0
assert span.get_metric("out.port") == MYSQL_CONFIG.get("port")
meta = {}
meta.update(self.DB_INFO)
assert_dict_issuperset(span.meta, meta)
fetch_span = spans[1]
assert fetch_span.name == "pymysql.query.fetchall"