def test_signature_create_keyspace():
assert (
extract_signature(
"CREATE KEYSPACE testkeyspace WITH REPLICATION = { 'class' : 'NetworkTopologyStrategy', 'datacenter1' : 3 };"
)
== "CREATE KEYSPACE"
)
async def call(self, module, method, wrapped, instance, args, kwargs):
if method == "Cursor.execute":
query = args[0]
name = extract_signature(query)
# Truncate sql_string to 10000 characters to prevent large queries from
# causing an error to APM server.
query = shorten(query, string_length=10000)
context = {
"db": {
"type": "sql",
"statement": query
},
"destination": {
"address": instance.connection.host,
"port": instance.connection.port,
"service": {
"name": "mysql",
"resource": "mysql",
"type": "db"
},
},
}
action = "query"
else:
raise AssertionError("call from uninstrumented method")
async with async_capture_span(name,
leaf=True,
span_type="db",
span_subtype="mysql",
span_action=action,
extra=context):
return await wrapped(*args, **kwargs)
def call(self, module, method, wrapped, instance, args, kwargs):
name = self.get_wrapped_name(wrapped, instance, method)
context = None
if method == "Cluster.connect":
span_action = "connect"
else:
span_action = "query"
query = args[0] if args else kwargs.get("query")
if hasattr(query, "query_string"):
query_str = query.query_string
elif hasattr(query, "prepared_statement") and hasattr(
query.prepared_statement, "query"):
query_str = query.prepared_statement.query
elif isinstance(query, compat.string_types):
query_str = query
else:
query_str = None
if query_str:
name = extract_signature(query_str)
context = {"db": {"type": "sql", "statement": query_str}}
with capture_span(name,
span_type="db",
span_subtype="cassandra",
span_action=span_action,
extra=context):
return wrapped(*args, **kwargs)
def test_signature_create_columnfamily():
assert (extract_signature("""CREATE COLUMNFAMILY users (
userid text PRIMARY KEY,
first_name text,
last_name text,
emails set<text>,
top_scores list<int>,
todo map<timestamp, text>
);""") == "CREATE COLUMNFAMILY")
def _trace_sql(self, method, sql, params):
signature = extract_signature(sql)
kind = "db.sqlite.sql"
with capture_span(signature, kind,
{"db": {
"type": "sql",
"statement": sql
}}):
if params is None:
return method(sql)
else:
return method(sql, params)
async def call(self, module, method, wrapped, instance, args, kwargs):
query = args[0] if len(args) else kwargs["query"]
name = extract_signature(query)
context = {"db": {"type": "sql", "statement": query}}
action = "query"
async with async_capture_span(name,
leaf=True,
span_type="db",
span_subtype="postgres",
span_action=action,
extra=context):
return await wrapped(*args, **kwargs)
def _trace_sql(self, method, sql, params):
signature = extract_signature(sql)
with capture_span(
signature,
span_type="db",
span_subtype="sqlite",
span_action="query",
extra={"db": {"type": "sql", "statement": sql}},
):
if params is None:
return method(sql)
else:
return method(sql, params)
def call(self, module, method, wrapped, instance, args, kwargs):
name = self.get_wrapped_name(wrapped, instance, method)
context = {}
if method == "Cluster.connect":
span_action = "connect"
if hasattr(instance,
"contact_points_resolved"): # < cassandra-driver 3.18
host = instance.contact_points_resolved[0]
port = instance.port
else:
host = instance.endpoints_resolved[0].address
port = instance.endpoints_resolved[0].port
else:
hosts = list(instance.hosts)
if hasattr(hosts[0], "endpoint"):
host = hosts[0].endpoint.address
port = hosts[0].endpoint.port
else:
# < cassandra-driver 3.18
host = hosts[0].address
port = instance.cluster.port
span_action = "query"
query = args[0] if args else kwargs.get("query")
if hasattr(query, "query_string"):
query_str = query.query_string
elif hasattr(query, "prepared_statement") and hasattr(
query.prepared_statement, "query"):
query_str = query.prepared_statement.query
elif isinstance(query, compat.string_types):
query_str = query
else:
query_str = None
if query_str:
name = extract_signature(query_str)
context["db"] = {"type": "sql", "statement": query_str}
context["destination"] = {
"address": host,
"port": port,
"service": {
"name": "cassandra",
"resource": "cassandra",
"type": "db"
},
}
with capture_span(name,
span_type="db",
span_subtype="cassandra",
span_action=span_action,
extra=context):
return wrapped(*args, **kwargs)
async def call(self, module, method, wrapped, instance, args, kwargs):
if method == "Cursor.execute":
query = args[0] if len(args) else kwargs["operation"]
query = _bake_sql(instance.raw, query)
name = extract_signature(query)
context = {"db": {"type": "sql", "statement": query}}
action = "query"
elif method == "Cursor.callproc":
func = args[0] if len(args) else kwargs["procname"]
name = func + "()"
context = None
action = "exec"
else:
raise AssertionError("call from uninstrumented method")
async with async_capture_span(
name, leaf=True, span_type="db", span_subtype="postgres", span_action=action, extra=context
):
return await wrapped(*args, **kwargs)
async def call(self, module, method, wrapped, instance, args, kwargs):
query = args[0] if len(args) else kwargs["query"]
name = extract_signature(query)
context = {"db": {"type": "sql", "statement": query}}
action = "query"
destination_info = {
"address": kwargs.get("host", "localhost"),
"port": int(kwargs.get("port", default_ports.get("postgresql"))),
"service": {
"name": "postgres",
"resource": "postgres",
"type": "db"
},
}
context["destination"] = destination_info
async with async_capture_span(name,
leaf=True,
span_type="db",
span_subtype="postgres",
span_action=action,
extra=context):
return await wrapped(*args, **kwargs)
def call(self, module, method, wrapped, instance, args, kwargs):
name = self.get_wrapped_name(wrapped, instance, method)
context = None
if method == "Cluster.connect":
span_type = 'db.cassandra.connect'
else:
span_type = 'db.cassandra.query'
query = args[0] if args else kwargs.get('query')
if hasattr(query, 'query_string'):
query_str = query.query_string
elif hasattr(query, 'prepared_statement') and hasattr(
query.prepared_statement, 'query'):
query_str = query.prepared_statement.query
elif isinstance(query, compat.string_types):
query_str = query
else:
query_str = None
if query_str:
name = extract_signature(query_str)
context = {'db': {"type": "sql", "statement": query_str}}
with capture_span(name, span_type, context):
return wrapped(*args, **kwargs)
async def call(self, module, method, wrapped, instance, args, kwargs):
query = self.get_query(method, args)
name = extract_signature(query)
sql_string = shorten(query, string_length=10000)
context = {"db": {"type": "sql", "statement": sql_string}}
action = "query"
destination_info = {
"address": kwargs.get("host", "localhost"),
"port": int(kwargs.get("port", default_ports.get("postgresql"))),
"service": {
"name": "",
"resource": "postgresql",
"type": ""
},
}
context["destination"] = destination_info
async with async_capture_span(name,
leaf=True,
span_type="db",
span_subtype="postgresql",
span_action=action,
extra=context):
return await wrapped(*args, **kwargs)
def test_select_from_collection():
assert extract_signature("SELECT first, last FROM a.b WHERE id = 1;") == "SELECT FROM a.b"
def extract_signature(self, sql):
return extract_signature(sql)
def test_extract_signature_bytes():
sql = b"Hello 'Peter Pan' at Disney World"
actual = extract_signature(sql)
expected = "HELLO"
assert actual == expected
