diff --git a/src/instana/__init__.py b/src/instana/__init__.py index 7ecf67a1..be2b84e1 100644 --- a/src/instana/__init__.py +++ b/src/instana/__init__.py @@ -166,7 +166,7 @@ def boot_agent(): asyncio, # noqa: F401 boto3_inst, # noqa: F401 # cassandra_inst, # noqa: F401 - # couchbase_inst, # noqa: F401 + couchbase_inst, # noqa: F401 fastapi_inst, # noqa: F401 flask, # noqa: F401 # gevent_inst, # noqa: F401 diff --git a/src/instana/instrumentation/couchbase_inst.py b/src/instana/instrumentation/couchbase_inst.py index f65c639a..cb97e042 100644 --- a/src/instana/instrumentation/couchbase_inst.py +++ b/src/instana/instrumentation/couchbase_inst.py @@ -6,18 +6,21 @@ https://docs.couchbase.com/python-sdk/2.5/start-using-sdk.html """ +from typing import Any, Callable, Dict, Tuple, Union + import wrapt -from ..log import logger -from ..util.traceutils import get_tracer_tuple, tracing_is_off +from instana.log import logger +from instana.span.span import InstanaSpan +from instana.util.traceutils import get_tracer_tuple, tracing_is_off try: import couchbase + from couchbase.bucket import Bucket - if not (hasattr(couchbase, '__version__') and couchbase.__version__[0] == '2' - and (couchbase.__version__[2] > '3' - or (couchbase.__version__[2] == '3' and couchbase.__version__[4] >= '4')) - ): + if not hasattr(couchbase, "__version__") and ( + couchbase.__version__ < "2.3.4" or couchbase.__version__ >= "3.0.0" + ): logger.debug("Instana supports 2.3.4 <= couchbase_versions < 3.0.0. Skipping.") raise ImportError @@ -25,71 +28,121 @@ # List of operations to instrument # incr, incr_multi, decr, decr_multi, retrieve_in are wrappers around operations above - operations = ['upsert', 'insert', 'replace', 'append', 'prepend', 'get', 'rget', - 'touch', 'lock', 'unlock', 'remove', 'counter', 'mutate_in', 'lookup_in', - 'stats', 'ping', 'diagnostics', 'observe', - - 'upsert_multi', 'insert_multi', 'replace_multi', 'append_multi', - 'prepend_multi', 'get_multi', 'touch_multi', 'lock_multi', 'unlock_multi', - 'observe_multi', 'endure_multi', 'remove_multi', 'counter_multi'] - - def capture_kvs(scope, instance, query_arg, op): + operations = [ + "upsert", + "insert", + "replace", + "append", + "prepend", + "get", + "rget", + "touch", + "lock", + "unlock", + "remove", + "counter", + "mutate_in", + "lookup_in", + "stats", + "ping", + "diagnostics", + "observe", + "upsert_multi", + "insert_multi", + "replace_multi", + "append_multi", + "prepend_multi", + "get_multi", + "touch_multi", + "lock_multi", + "unlock_multi", + "observe_multi", + "endure_multi", + "remove_multi", + "counter_multi", + ] + + def collect_attributes( + span: InstanaSpan, + instance: Bucket, + query_arg: Union[N1QLQuery, object], + op: str, + ) -> None: try: - scope.span.set_tag('couchbase.hostname', instance.server_nodes[0]) - scope.span.set_tag('couchbase.bucket', instance.bucket) - scope.span.set_tag('couchbase.type', op) + span.set_attribute("couchbase.hostname", instance.server_nodes[0]) + span.set_attribute("couchbase.bucket", instance.bucket) + span.set_attribute("couchbase.type", op) - if query_arg is not None: + if query_arg: query = None if type(query_arg) is N1QLQuery: query = query_arg.statement else: query = query_arg - scope.span.set_tag('couchbase.sql', query) - except: + span.set_attribute("couchbase.sql", query) + except Exception: # No fail on key capture - best effort pass - def make_wrapper(op): - def wrapper(wrapped, instance, args, kwargs): + def make_wrapper(op: str) -> Callable: + def wrapper( + wrapped: Callable[..., object], + instance: couchbase.bucket.Bucket, + args: Tuple[object, ...], + kwargs: Dict[str, Any], + ) -> object: tracer, parent_span, _ = get_tracer_tuple() + parent_context = parent_span.get_span_context() if parent_span else None # If we're not tracing, just return if tracing_is_off(): return wrapped(*args, **kwargs) - with tracer.start_active_span("couchbase", child_of=parent_span) as scope: - capture_kvs(scope, instance, None, op) + with tracer.start_as_current_span( + "couchbase", span_context=parent_context + ) as span: + collect_attributes(span, instance, None, op) try: return wrapped(*args, **kwargs) - except Exception as e: - scope.span.log_exception(e) - scope.span.set_tag('couchbase.error', repr(e)) - raise + except Exception as exc: + span.record_exception(exc) + span.set_attribute("couchbase.error", repr(exc)) + logger.debug("Instana couchbase @ wrapper", exc_info=True) + return wrapper - def query_with_instana(wrapped, instance, args, kwargs): + def query_with_instana( + wrapped: Callable[..., object], + instance: couchbase.bucket.Bucket, + args: Tuple[object, ...], + kwargs: Dict[str, Any], + ) -> object: tracer, parent_span, _ = get_tracer_tuple() + parent_context = parent_span.get_span_context() if parent_span else None # If we're not tracing, just return if tracing_is_off(): return wrapped(*args, **kwargs) - with tracer.start_active_span("couchbase", child_of=parent_span) as scope: - capture_kvs(scope, instance, args[0], 'n1ql_query') + with tracer.start_as_current_span( + "couchbase", span_context=parent_context + ) as span: try: + collect_attributes(span, instance, args[0], "n1ql_query") return wrapped(*args, **kwargs) - except Exception as e: - scope.span.log_exception(e) - scope.span.set_tag('couchbase.error', repr(e)) - raise + except Exception as exc: + span.record_exception(exc) + span.set_attribute("couchbase.error", repr(exc)) + logger.debug("Instana couchbase @ query_with_instana", exc_info=True) logger.debug("Instrumenting couchbase") - wrapt.wrap_function_wrapper('couchbase.bucket', 'Bucket.n1ql_query', query_with_instana) + wrapt.wrap_function_wrapper( + "couchbase.bucket", "Bucket.n1ql_query", query_with_instana + ) for op in operations: f = make_wrapper(op) - wrapt.wrap_function_wrapper('couchbase.bucket', 'Bucket.%s' % op, f) + wrapt.wrap_function_wrapper("couchbase.bucket", f"Bucket.{op}", f) except ImportError: pass diff --git a/tests/clients/test_couchbase.py b/tests/clients/test_couchbase.py index 61cdf6ef..9064fb06 100644 --- a/tests/clients/test_couchbase.py +++ b/tests/clients/test_couchbase.py @@ -3,175 +3,192 @@ import os import time -import unittest +from typing import Generator +from unittest.mock import patch + +import pytest from instana.singletons import agent, tracer -from ..helpers import testenv, get_first_span_by_name, get_first_span_by_filter +from tests.helpers import testenv, get_first_span_by_name, get_first_span_by_filter from couchbase.admin import Admin from couchbase.cluster import Cluster from couchbase.bucket import Bucket -from couchbase.exceptions import CouchbaseTransientError, HTTPError, KeyExistsError, NotFoundError +from couchbase.exceptions import ( + CouchbaseTransientError, + HTTPError, + KeyExistsError, + NotFoundError, +) import couchbase.subdocument as SD from couchbase.n1ql import N1QLQuery # Delete any pre-existing buckets. Create new. -cb_adm = Admin(testenv['couchdb_username'], testenv['couchdb_password'], host=testenv['couchdb_host'], port=8091) +cb_adm = Admin( + testenv["couchdb_username"], + testenv["couchdb_password"], + host=testenv["couchdb_host"], + port=8091, +) # Make sure a test bucket exists try: - cb_adm.bucket_create('travel-sample') - cb_adm.wait_ready('travel-sample', timeout=30) + cb_adm.bucket_create("travel-sample") + cb_adm.wait_ready("travel-sample", timeout=30) except HTTPError: pass -@unittest.skipIf(not os.environ.get("COUCHBASE_TEST"), reason="") -class TestStandardCouchDB(unittest.TestCase): - def setup_class(self): - """ Clear all spans before a test run """ - self.recorder = tracer.recorder - self.cluster = Cluster('couchbase://%s' % testenv['couchdb_host']) - self.bucket = Bucket('couchbase://%s/travel-sample' % testenv['couchdb_host'], - username=testenv['couchdb_username'], password=testenv['couchdb_password']) - - def tearDown(self): - """ Ensure that allow_exit_as_root has the default value """ - agent.options.allow_exit_as_root = False - - def setup_method(self, _): - self.bucket.upsert('test-key', 1) +class TestStandardCouchDB: + @pytest.fixture(autouse=True) + def _resource(self) -> Generator[None, None, None]: + """Clear all spans before a test run""" + self.recorder = tracer.span_processor + self.cluster = Cluster("couchbase://%s" % testenv["couchdb_host"]) + self.bucket = Bucket( + "couchbase://%s/travel-sample" % testenv["couchdb_host"], + username=testenv["couchdb_username"], + password=testenv["couchdb_password"], + ) + self.bucket.upsert("test-key", 1) time.sleep(0.5) self.recorder.clear_spans() + yield + agent.options.allow_exit_as_root = False - def test_vanilla_get(self): + def test_vanilla_get(self) -> None: res = self.bucket.get("test-key") - self.assertTrue(res) - - def test_pipeline(self): - pass + assert res - def test_upsert(self): + def test_upsert(self) -> None: res = None - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.upsert("test_upsert", 1) - self.assertTrue(res) - self.assertTrue(res.success) + assert res + assert res.success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'upsert') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "upsert" - def test_upsert_as_root_exit_span(self): + def test_upsert_as_root_exit_span(self) -> None: agent.options.allow_exit_as_root = True res = self.bucket.upsert("test_upsert", 1) - self.assertTrue(res) - self.assertTrue(res.success) + assert res + assert res.success spans = self.recorder.queued_spans() - self.assertEqual(1, len(spans)) + assert len(spans) == 1 - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span - self.assertEqual(cb_span.p, None) + assert not cb_span.p - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'upsert') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "upsert" - def test_upsert_multi(self): + def test_upsert_multi(self) -> None: res = None - kvs = dict() - kvs['first_test_upsert_multi'] = 1 - kvs['second_test_upsert_multi'] = 1 + kvs = {} + kvs["first_test_upsert_multi"] = 1 + kvs["second_test_upsert_multi"] = 1 - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.upsert_multi(kvs) - self.assertTrue(res) - self.assertTrue(res['first_test_upsert_multi'].success) - self.assertTrue(res['second_test_upsert_multi'].success) + assert res + assert res["first_test_upsert_multi"].success + assert res["second_test_upsert_multi"].success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'upsert_multi') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "upsert_multi" - def test_insert_new(self): + def test_insert_new(self) -> None: res = None try: - self.bucket.remove('test_insert_new') + self.bucket.remove("test_insert_new") except NotFoundError: pass - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.insert("test_insert_new", 1) - self.assertTrue(res) - self.assertTrue(res.success) + assert res + assert res.success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'insert') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "insert" - def test_insert_existing(self): + def test_insert_existing(self) -> None: res = None try: self.bucket.insert("test_insert", 1) @@ -179,113 +196,119 @@ def test_insert_existing(self): pass try: - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.insert("test_insert", 1) except KeyExistsError: pass - self.assertIsNone(res) + assert not res spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertEqual(cb_span.ec, 1) + assert cb_span.stack + assert cb_span.ec == 1 # Just search for the substring of the exception class found = cb_span.data["couchbase"]["error"].find("_KeyExistsError") - self.assertFalse(found == -1, "Error substring not found.") + assert not found == -1 - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'insert') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "insert" - def test_insert_multi(self): + def test_insert_multi(self) -> None: res = None - kvs = dict() - kvs['first_test_upsert_multi'] = 1 - kvs['second_test_upsert_multi'] = 1 + kvs = {} + kvs["first_test_upsert_multi"] = 1 + kvs["second_test_upsert_multi"] = 1 try: - self.bucket.remove('first_test_upsert_multi') - self.bucket.remove('second_test_upsert_multi') + self.bucket.remove("first_test_upsert_multi") + self.bucket.remove("second_test_upsert_multi") except NotFoundError: pass - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.insert_multi(kvs) - self.assertTrue(res) - self.assertTrue(res['first_test_upsert_multi'].success) - self.assertTrue(res['second_test_upsert_multi'].success) + assert res + assert res["first_test_upsert_multi"].success + assert res["second_test_upsert_multi"].success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'insert_multi') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "insert_multi" - def test_replace(self): + def test_replace(self) -> None: res = None try: self.bucket.insert("test_replace", 1) except KeyExistsError: pass - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.replace("test_replace", 2) - self.assertTrue(res) - self.assertTrue(res.success) + assert res + assert res.success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'replace') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "replace" - def test_replace_non_existent(self): + def test_replace_non_existent(self) -> None: res = None try: @@ -294,969 +317,1102 @@ def test_replace_non_existent(self): pass try: - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.replace("test_replace", 2) except NotFoundError: pass - self.assertIsNone(res) + assert not res spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertEqual(cb_span.ec, 1) + assert cb_span.stack + assert cb_span.ec == 1 # Just search for the substring of the exception class found = cb_span.data["couchbase"]["error"].find("NotFoundError") - self.assertFalse(found == -1, "Error substring not found.") + assert not found == -1 - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'replace') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "replace" - def test_replace_multi(self): + def test_replace_multi(self) -> None: res = None - kvs = dict() - kvs['first_test_replace_multi'] = 1 - kvs['second_test_replace_multi'] = 1 + kvs = {} + kvs["first_test_replace_multi"] = 1 + kvs["second_test_replace_multi"] = 1 - self.bucket.upsert('first_test_replace_multi', "one") - self.bucket.upsert('second_test_replace_multi', "two") + self.bucket.upsert("first_test_replace_multi", "one") + self.bucket.upsert("second_test_replace_multi", "two") - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.replace_multi(kvs) - self.assertTrue(res) - self.assertTrue(res['first_test_replace_multi'].success) - self.assertTrue(res['second_test_replace_multi'].success) + assert res + assert res["first_test_replace_multi"].success + assert res["second_test_replace_multi"].success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'replace_multi') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "replace_multi" - def test_append(self): + def test_append(self) -> None: self.bucket.upsert("test_append", "one") res = None - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.append("test_append", "two") - self.assertTrue(res) - self.assertTrue(res.success) + assert res + assert res.success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'append') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "append" - def test_append_multi(self): + def test_append_multi(self) -> None: res = None kvs = dict() - kvs['first_test_append_multi'] = "ok1" - kvs['second_test_append_multi'] = "ok2" + kvs["first_test_append_multi"] = "ok1" + kvs["second_test_append_multi"] = "ok2" - self.bucket.upsert('first_test_append_multi', "one") - self.bucket.upsert('second_test_append_multi', "two") + self.bucket.upsert("first_test_append_multi", "one") + self.bucket.upsert("second_test_append_multi", "two") - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.append_multi(kvs) - self.assertTrue(res) - self.assertTrue(res['first_test_append_multi'].success) - self.assertTrue(res['second_test_append_multi'].success) + assert res + assert res["first_test_append_multi"].success + assert res["second_test_append_multi"].success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'append_multi') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "append_multi" - def test_prepend(self): + def test_prepend(self) -> None: self.bucket.upsert("test_prepend", "one") res = None - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.prepend("test_prepend", "two") - self.assertTrue(res) - self.assertTrue(res.success) + assert res + assert res.success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'prepend') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "prepend" - def test_prepend_multi(self): + def test_prepend_multi(self) -> None: res = None - kvs = dict() - kvs['first_test_prepend_multi'] = "ok1" - kvs['second_test_prepend_multi'] = "ok2" + kvs = {} + kvs["first_test_prepend_multi"] = "ok1" + kvs["second_test_prepend_multi"] = "ok2" - self.bucket.upsert('first_test_prepend_multi', "one") - self.bucket.upsert('second_test_prepend_multi', "two") + self.bucket.upsert("first_test_prepend_multi", "one") + self.bucket.upsert("second_test_prepend_multi", "two") - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.prepend_multi(kvs) - self.assertTrue(res) - self.assertTrue(res['first_test_prepend_multi'].success) - self.assertTrue(res['second_test_prepend_multi'].success) + assert res + assert res["first_test_prepend_multi"].success + assert res["second_test_prepend_multi"].success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'prepend_multi') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "prepend_multi" - def test_get(self): + def test_get(self) -> None: res = None - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.get("test-key") - self.assertTrue(res) - self.assertTrue(res.success) + assert res + assert res.success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'get') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "get" - def test_rget(self): + def test_rget(self) -> None: res = None try: - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.rget("test-key", replica_index=None) except CouchbaseTransientError: pass - self.assertIsNone(res) + assert not res spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertEqual(cb_span.ec, 1) + assert cb_span.stack + assert cb_span.ec == 1 # Just search for the substring of the exception class found = cb_span.data["couchbase"]["error"].find("CouchbaseTransientError") - self.assertFalse(found == -1, "Error substring not found.") + assert found != -1 - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'rget') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "rget" - def test_get_not_found(self): + def test_get_not_found(self) -> None: res = None try: - self.bucket.remove('test_get_not_found') + self.bucket.remove("test_get_not_found") except NotFoundError: pass try: - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.get("test_get_not_found") except NotFoundError: pass - self.assertIsNone(res) + assert not res spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertEqual(cb_span.ec, 1) + assert cb_span.stack + assert cb_span.ec == 1 # Just search for the substring of the exception class found = cb_span.data["couchbase"]["error"].find("NotFoundError") - self.assertFalse(found == -1, "Error substring not found.") + assert found != -1 - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'get') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "get" - def test_get_multi(self): + def test_get_multi(self) -> None: res = None - self.bucket.upsert('first_test_get_multi', "one") - self.bucket.upsert('second_test_get_multi', "two") + self.bucket.upsert("first_test_get_multi", "one") + self.bucket.upsert("second_test_get_multi", "two") - with tracer.start_active_span('test'): - res = self.bucket.get_multi(['first_test_get_multi', 'second_test_get_multi']) + with tracer.start_as_current_span("test"): + res = self.bucket.get_multi( + ["first_test_get_multi", "second_test_get_multi"] + ) - self.assertTrue(res) - self.assertTrue(res['first_test_get_multi'].success) - self.assertTrue(res['second_test_get_multi'].success) + assert res + assert res["first_test_get_multi"].success + assert res["second_test_get_multi"].success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'get_multi') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "get_multi" - def test_touch(self): + def test_touch(self) -> None: res = None self.bucket.upsert("test_touch", 1) - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.touch("test_touch") - self.assertTrue(res) - self.assertTrue(res.success) + assert res + assert res.success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'touch') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "touch" - def test_touch_multi(self): + def test_touch_multi(self) -> None: res = None - self.bucket.upsert('first_test_touch_multi', "one") - self.bucket.upsert('second_test_touch_multi', "two") + self.bucket.upsert("first_test_touch_multi", "one") + self.bucket.upsert("second_test_touch_multi", "two") - with tracer.start_active_span('test'): - res = self.bucket.touch_multi(['first_test_touch_multi', 'second_test_touch_multi']) + with tracer.start_as_current_span("test"): + res = self.bucket.touch_multi( + ["first_test_touch_multi", "second_test_touch_multi"] + ) - self.assertTrue(res) - self.assertTrue(res['first_test_touch_multi'].success) - self.assertTrue(res['second_test_touch_multi'].success) + assert res + assert res["first_test_touch_multi"].success + assert res["second_test_touch_multi"].success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'touch_multi') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "touch_multi" - def test_lock(self): + def test_lock(self) -> None: res = None self.bucket.upsert("test_lock_unlock", "lock_this") - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): rv = self.bucket.lock("test_lock_unlock", ttl=5) - self.assertTrue(rv) - self.assertTrue(rv.success) + assert rv + assert rv.success # upsert automatically unlocks the key res = self.bucket.upsert("test_lock_unlock", "updated", rv.cas) - self.assertTrue(res) - self.assertTrue(res.success) + assert res + assert res.success spans = self.recorder.queued_spans() - self.assertEqual(3, len(spans)) + assert len(spans) == 3 + + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + def filter(span): + return span.n == "couchbase" and span.data["couchbase"]["type"] == "lock" - filter = lambda span: span.n == "couchbase" and span.data["couchbase"]["type"] == "lock" cb_lock_span = get_first_span_by_filter(spans, filter) - self.assertTrue(cb_lock_span) + assert cb_lock_span + + def filter(span): + return span.n == "couchbase" and span.data["couchbase"]["type"] == "upsert" - filter = lambda span: span.n == "couchbase" and span.data["couchbase"]["type"] == "upsert" cb_upsert_span = get_first_span_by_filter(spans, filter) - self.assertTrue(cb_upsert_span) + assert cb_upsert_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_lock_span.t) - self.assertEqual(test_span.t, cb_upsert_span.t) - - self.assertEqual(cb_lock_span.p, test_span.s) - self.assertEqual(cb_upsert_span.p, test_span.s) - - self.assertTrue(cb_lock_span.stack) - self.assertIsNone(cb_lock_span.ec) - self.assertTrue(cb_upsert_span.stack) - self.assertIsNone(cb_upsert_span.ec) - - self.assertEqual(cb_lock_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_lock_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_lock_span.data["couchbase"]["type"], 'lock') - self.assertEqual(cb_upsert_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_upsert_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_upsert_span.data["couchbase"]["type"], 'upsert') - - def test_lock_unlock(self): + assert cb_lock_span.t == test_span.t + assert cb_upsert_span.t == test_span.t + + assert cb_lock_span.p == test_span.s + assert cb_upsert_span.p == test_span.s + + assert cb_lock_span.stack + assert not cb_lock_span.ec + assert cb_upsert_span.stack + assert not cb_upsert_span.ec + + assert ( + cb_lock_span.data["couchbase"]["hostname"] + == f"{testenv['couchdb_host']}:8091" + ) + assert cb_lock_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_lock_span.data["couchbase"]["type"] == "lock" + assert ( + cb_upsert_span.data["couchbase"]["hostname"] + == f"{testenv['couchdb_host']}:8091" + ) + assert cb_upsert_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_upsert_span.data["couchbase"]["type"] == "upsert" + + def test_lock_unlock(self) -> None: res = None self.bucket.upsert("test_lock_unlock", "lock_this") - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): rv = self.bucket.lock("test_lock_unlock", ttl=5) - self.assertTrue(rv) - self.assertTrue(rv.success) + assert rv + assert rv.success # upsert automatically unlocks the key res = self.bucket.unlock("test_lock_unlock", rv.cas) - self.assertTrue(res) - self.assertTrue(res.success) + assert res + assert res.success spans = self.recorder.queued_spans() - self.assertEqual(3, len(spans)) + assert len(spans) == 3 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" + + def filter(span): + return span.n == "couchbase" and span.data["couchbase"]["type"] == "lock" - filter = lambda span: span.n == "couchbase" and span.data["couchbase"]["type"] == "lock" cb_lock_span = get_first_span_by_filter(spans, filter) - self.assertTrue(cb_lock_span) + assert cb_lock_span + + def filter(span): + return span.n == "couchbase" and span.data["couchbase"]["type"] == "unlock" - filter = lambda span: span.n == "couchbase" and span.data["couchbase"]["type"] == "unlock" cb_unlock_span = get_first_span_by_filter(spans, filter) - self.assertTrue(cb_unlock_span) + assert cb_unlock_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_lock_span.t) - self.assertEqual(test_span.t, cb_unlock_span.t) - - self.assertEqual(cb_lock_span.p, test_span.s) - self.assertEqual(cb_unlock_span.p, test_span.s) - - self.assertTrue(cb_lock_span.stack) - self.assertIsNone(cb_lock_span.ec) - self.assertTrue(cb_unlock_span.stack) - self.assertIsNone(cb_unlock_span.ec) - - self.assertEqual(cb_lock_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_lock_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_lock_span.data["couchbase"]["type"], 'lock') - self.assertEqual(cb_unlock_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_unlock_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_unlock_span.data["couchbase"]["type"], 'unlock') - - def test_lock_unlock_muilti(self): + assert cb_lock_span.t == test_span.t + assert cb_unlock_span.t == test_span.t + + assert cb_lock_span.p == test_span.s + assert cb_unlock_span.p == test_span.s + + assert cb_lock_span.stack + assert not cb_lock_span.ec + assert cb_unlock_span.stack + assert not cb_unlock_span.ec + + assert ( + cb_lock_span.data["couchbase"]["hostname"] + == f"{testenv['couchdb_host']}:8091" + ) + assert cb_lock_span.data["couchbase"]["bucket"], "travel-sample" + assert cb_lock_span.data["couchbase"]["type"], "lock" + assert ( + cb_unlock_span.data["couchbase"]["hostname"] + == f"{testenv['couchdb_host']}:8091" + ) + assert cb_unlock_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_unlock_span.data["couchbase"]["type"] == "unlock" + + def test_lock_unlock_muilti(self) -> None: res = None self.bucket.upsert("test_lock_unlock_multi_1", "lock_this") self.bucket.upsert("test_lock_unlock_multi_2", "lock_this") keys_to_lock = ("test_lock_unlock_multi_1", "test_lock_unlock_multi_2") - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): rv = self.bucket.lock_multi(keys_to_lock, ttl=5) - self.assertTrue(rv) - self.assertTrue(rv['test_lock_unlock_multi_1'].success) - self.assertTrue(rv['test_lock_unlock_multi_2'].success) + assert rv + assert rv["test_lock_unlock_multi_1"].success + assert rv["test_lock_unlock_multi_2"].success res = self.bucket.unlock_multi(rv) - self.assertTrue(res) + assert res spans = self.recorder.queued_spans() - self.assertEqual(3, len(spans)) + assert len(spans) == 3 + + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + def filter(span): + return ( + span.n == "couchbase" and span.data["couchbase"]["type"] == "lock_multi" + ) - filter = lambda span: span.n == "couchbase" and span.data["couchbase"]["type"] == "lock_multi" cb_lock_span = get_first_span_by_filter(spans, filter) - self.assertTrue(cb_lock_span) + assert cb_lock_span + + def filter(span): + return ( + span.n == "couchbase" + and span.data["couchbase"]["type"] == "unlock_multi" + ) - filter = lambda span: span.n == "couchbase" and span.data["couchbase"]["type"] == "unlock_multi" cb_unlock_span = get_first_span_by_filter(spans, filter) - self.assertTrue(cb_unlock_span) + assert cb_unlock_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_lock_span.t) - self.assertEqual(test_span.t, cb_unlock_span.t) - - self.assertEqual(cb_lock_span.p, test_span.s) - self.assertEqual(cb_unlock_span.p, test_span.s) - - self.assertTrue(cb_lock_span.stack) - self.assertIsNone(cb_lock_span.ec) - self.assertTrue(cb_unlock_span.stack) - self.assertIsNone(cb_unlock_span.ec) - - self.assertEqual(cb_lock_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_lock_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_lock_span.data["couchbase"]["type"], 'lock_multi') - self.assertEqual(cb_unlock_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_unlock_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_unlock_span.data["couchbase"]["type"], 'unlock_multi') - - def test_remove(self): + assert cb_lock_span.t == test_span.t + assert cb_unlock_span.t == test_span.t + + assert cb_lock_span.p == test_span.s + assert cb_unlock_span.p == test_span.s + + assert cb_lock_span.stack + assert not cb_lock_span.ec + assert cb_unlock_span.stack + assert not cb_unlock_span.ec + + assert ( + cb_lock_span.data["couchbase"]["hostname"] + == f"{testenv['couchdb_host']}:8091" + ) + assert cb_lock_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_lock_span.data["couchbase"]["type"] == "lock_multi" + assert ( + cb_unlock_span.data["couchbase"]["hostname"] + == f"{testenv['couchdb_host']}:8091" + ) + assert cb_unlock_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_unlock_span.data["couchbase"]["type"] == "unlock_multi" + + def test_remove(self) -> None: res = None self.bucket.upsert("test_remove", 1) - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.remove("test_remove") - self.assertTrue(res) - self.assertTrue(res.success) + assert res + assert res.success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'remove') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "remove" - def test_remove_multi(self): + def test_remove_multi(self) -> None: res = None self.bucket.upsert("test_remove_multi_1", 1) self.bucket.upsert("test_remove_multi_2", 1) keys_to_remove = ("test_remove_multi_1", "test_remove_multi_2") - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.remove_multi(keys_to_remove) - self.assertTrue(res) - self.assertTrue(res['test_remove_multi_1'].success) - self.assertTrue(res['test_remove_multi_2'].success) + assert res + assert res["test_remove_multi_1"].success + assert res["test_remove_multi_2"].success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'remove_multi') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "remove_multi" - def test_counter(self): + def test_counter(self) -> None: res = None self.bucket.upsert("test_counter", 1) - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.counter("test_counter", delta=10) - self.assertTrue(res) - self.assertTrue(res.success) + assert res + assert res.success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'counter') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "counter" - def test_counter_multi(self): + def test_counter_multi(self) -> None: res = None self.bucket.upsert("first_test_counter", 1) self.bucket.upsert("second_test_counter", 1) - with tracer.start_active_span('test'): - res = self.bucket.counter_multi(("first_test_counter", "second_test_counter")) + with tracer.start_as_current_span("test"): + res = self.bucket.counter_multi( + ("first_test_counter", "second_test_counter") + ) - self.assertTrue(res) - self.assertTrue(res['first_test_counter'].success) - self.assertTrue(res['second_test_counter'].success) + assert res + assert res["first_test_counter"].success + assert res["second_test_counter"].success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'counter_multi') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "counter_multi" - def test_mutate_in(self): + def test_mutate_in(self) -> None: res = None - self.bucket.upsert('king_arthur', {'name': 'Arthur', 'email': 'kingarthur@couchbase.com', - 'interests': ['Holy Grail', 'African Swallows']}) - - with tracer.start_active_span('test'): - res = self.bucket.mutate_in('king_arthur', - SD.array_addunique('interests', 'Cats'), - SD.counter('updates', 1)) - - self.assertTrue(res) - self.assertTrue(res.success) + self.bucket.upsert( + "king_arthur", + { + "name": "Arthur", + "email": "kingarthur@couchbase.com", + "interests": ["Holy Grail", "African Swallows"], + }, + ) + + with tracer.start_as_current_span("test"): + res = self.bucket.mutate_in( + "king_arthur", + SD.array_addunique("interests", "Cats"), + SD.counter("updates", 1), + ) + + assert res + assert res.success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'mutate_in') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "mutate_in" - def test_lookup_in(self): + def test_lookup_in(self) -> None: res = None - self.bucket.upsert('king_arthur', {'name': 'Arthur', 'email': 'kingarthur@couchbase.com', - 'interests': ['Holy Grail', 'African Swallows']}) - - with tracer.start_active_span('test'): - res = self.bucket.lookup_in('king_arthur', - SD.get('email'), - SD.get('interests')) - - self.assertTrue(res) - self.assertTrue(res.success) + self.bucket.upsert( + "king_arthur", + { + "name": "Arthur", + "email": "kingarthur@couchbase.com", + "interests": ["Holy Grail", "African Swallows"], + }, + ) + + with tracer.start_as_current_span("test"): + res = self.bucket.lookup_in( + "king_arthur", SD.get("email"), SD.get("interests") + ) + + assert res + assert res.success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'lookup_in') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "lookup_in" - def test_stats(self): + def test_stats(self) -> None: res = None - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.stats() - self.assertTrue(res) + assert res spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'stats') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "stats" - def test_ping(self): + def test_ping(self) -> None: res = None - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.ping() - self.assertTrue(res) + assert res spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'ping') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "ping" - def test_diagnostics(self): + def test_diagnostics(self) -> None: res = None - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.diagnostics() - self.assertTrue(res) + assert res spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'diagnostics') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "diagnostics" - def test_observe(self): + def test_observe(self) -> None: res = None - self.bucket.upsert('test_observe', 1) + self.bucket.upsert("test_observe", 1) - with tracer.start_active_span('test'): - res = self.bucket.observe('test_observe') + with tracer.start_as_current_span("test"): + res = self.bucket.observe("test_observe") - self.assertTrue(res) - self.assertTrue(res.success) + assert res + assert res.success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'observe') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "observe" - def test_observe_multi(self): + def test_observe_multi(self) -> None: res = None - self.bucket.upsert('test_observe_multi_1', 1) - self.bucket.upsert('test_observe_multi_2', 1) + self.bucket.upsert("test_observe_multi_1", 1) + self.bucket.upsert("test_observe_multi_2", 1) - keys_to_observe = ('test_observe_multi_1', 'test_observe_multi_2') + keys_to_observe = ("test_observe_multi_1", "test_observe_multi_2") - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"): res = self.bucket.observe_multi(keys_to_observe) - self.assertTrue(res) - self.assertTrue(res['test_observe_multi_1'].success) - self.assertTrue(res['test_observe_multi_2'].success) + assert res + assert res["test_observe_multi_1"].success + assert res["test_observe_multi_2"].success spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'observe_multi') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "observe_multi" - def test_raw_n1ql_query(self): + def test_query_with_instana_tracing_off(self) -> None: res = None - with tracer.start_active_span('test'): + with tracer.start_as_current_span("test"), patch( + "instana.instrumentation.couchbase_inst.tracing_is_off", return_value=True + ): res = self.bucket.n1ql_query("SELECT 1") + assert res - self.assertTrue(res) + def test_query_with_instana_exception(self) -> None: + with tracer.start_as_current_span("test"), patch( + "instana.instrumentation.couchbase_inst.collect_attributes", + side_effect=Exception("test-error"), + ): + self.bucket.n1ql_query("SELECT 1") spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + cb_span = get_first_span_by_name(spans, "couchbase") - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + assert cb_span.data["couchbase"]["error"] == "Exception('test-error')" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + def test_raw_n1ql_query(self) -> None: + res = None + + with tracer.start_as_current_span("test"): + res = self.bucket.n1ql_query("SELECT 1") + + assert res + + spans = self.recorder.queued_spans() + assert len(spans) == 2 + + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" + + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) + assert cb_span.stack + assert not cb_span.ec - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'n1ql_query') - self.assertEqual(cb_span.data["couchbase"]["sql"], 'SELECT 1') + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "n1ql_query" + assert cb_span.data["couchbase"]["sql"] == "SELECT 1" - def test_n1ql_query(self): + def test_n1ql_query(self) -> None: res = None - with tracer.start_active_span('test'): - res = self.bucket.n1ql_query(N1QLQuery('SELECT name FROM `travel-sample` WHERE brewery_id ="mishawaka_brewing"')) + with tracer.start_as_current_span("test"): + res = self.bucket.n1ql_query( + N1QLQuery( + 'SELECT name FROM `travel-sample` WHERE brewery_id ="mishawaka_brewing"' + ) + ) - self.assertTrue(res) + assert res spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + assert len(spans) == 2 - test_span = get_first_span_by_name(spans, 'sdk') - self.assertTrue(test_span) - self.assertEqual(test_span.data["sdk"]["name"], 'test') + test_span = get_first_span_by_name(spans, "sdk") + assert test_span + assert test_span.data["sdk"]["name"] == "test" - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertTrue(cb_span) + cb_span = get_first_span_by_name(spans, "couchbase") + assert cb_span # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) - - self.assertTrue(cb_span.stack) - self.assertIsNone(cb_span.ec) - - self.assertEqual(cb_span.data["couchbase"]["hostname"], "%s:8091" % testenv['couchdb_host']) - self.assertEqual(cb_span.data["couchbase"]["bucket"], 'travel-sample') - self.assertEqual(cb_span.data["couchbase"]["type"], 'n1ql_query') - self.assertEqual(cb_span.data["couchbase"]["sql"], 'SELECT name FROM `travel-sample` WHERE brewery_id ="mishawaka_brewing"') + assert cb_span.t == test_span.t + assert cb_span.p == test_span.s + + assert cb_span.stack + assert not cb_span.ec + + assert ( + cb_span.data["couchbase"]["hostname"] == f"{testenv['couchdb_host']}:8091" + ) + assert cb_span.data["couchbase"]["bucket"] == "travel-sample" + assert cb_span.data["couchbase"]["type"] == "n1ql_query" + assert ( + cb_span.data["couchbase"]["sql"] + == 'SELECT name FROM `travel-sample` WHERE brewery_id ="mishawaka_brewing"' + ) diff --git a/tests/conftest.py b/tests/conftest.py index b73954b1..45dccac3 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -38,7 +38,6 @@ # TODO: remove the following entries as the migration of the instrumentation # codes are finalised. collect_ignore_glob.append("*clients/test_cassandra*") -collect_ignore_glob.append("*clients/test_couchbase*") collect_ignore_glob.append("*clients/test_google*") collect_ignore_glob.append("*clients/test_pika*") collect_ignore_glob.append("*clients/test_redis*") @@ -56,8 +55,8 @@ # if not os.environ.get("CASSANDRA_TEST"): # collect_ignore_glob.append("*test_cassandra*") -# if not os.environ.get("COUCHBASE_TEST"): -# collect_ignore_glob.append("*test_couchbase*") +if not os.environ.get("COUCHBASE_TEST"): + collect_ignore_glob.append("*test_couchbase*") # if not os.environ.get("GEVENT_STARLETTE_TEST"): # collect_ignore_glob.append("*test_gevent*")