From 744beac4d36594bffce06b3e893230165b0c4f21 Mon Sep 17 00:00:00 2001 From: Peter Giacomo Lombardo Date: Tue, 26 Nov 2019 17:02:46 +0100 Subject: [PATCH 01/12] Couchbase support systems. --- .circleci/config.yml | 1 + instana/json_span.py | 8 ++++++++ instana/recorder.py | 16 +++++++++++++--- setup.py | 1 + 4 files changed, 23 insertions(+), 3 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index ca024bf5..b9a70755 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -115,6 +115,7 @@ jobs: - image: circleci/mariadb:10-ram - image: circleci/redis:5.0.4 - image: rabbitmq:3.5.4 + - image: couchbase:6.0.3 working_directory: ~/repo diff --git a/instana/json_span.py b/instana/json_span.py index 628c1986..db4fd523 100644 --- a/instana/json_span.py +++ b/instana/json_span.py @@ -48,6 +48,14 @@ class Data(BaseSpan): log = None +class CouchbaseData(BaseSpan): + hostname = None + bucket = None + type = None + error = None + error_code = None + + class HttpData(BaseSpan): host = None url = None diff --git a/instana/recorder.py b/instana/recorder.py index 8c4471e0..cd744503 100644 --- a/instana/recorder.py +++ b/instana/recorder.py @@ -9,7 +9,7 @@ import instana.singletons -from .json_span import (CustomData, Data, HttpData, JsonSpan, LogData, MySQLData, PostgresData, +from .json_span import (CouchbaseData, CustomData, Data, HttpData, JsonSpan, LogData, MySQLData, PostgresData, RabbitmqData, RedisData, RenderData, RPCData, SDKData, SoapData, SQLAlchemyData) from .log import logger @@ -23,15 +23,18 @@ class InstanaRecorder(SpanRecorder): THREAD_NAME = "Instana Span Reporting" - registered_spans = ("aiohttp-client", "aiohttp-server", "django", "log", "memcache", "mysql", + registered_spans = ("aiohttp-client", "aiohttp-server", "couchbase", "django", "log", "memcache", "mysql", "postgres", "rabbitmq", "redis", "render", "rpc-client", "rpc-server", "sqlalchemy", "soap", "tornado-client", "tornado-server", "urllib3", "wsgi") + http_spans = ("aiohttp-client", "aiohttp-server", "django", "http", "soap", "tornado-client", "tornado-server", "urllib3", "wsgi") - exit_spans = ("aiohttp-client", "log", "memcache", "mysql", "postgres", "rabbitmq", "redis", "rpc-client", + exit_spans = ("aiohttp-client", "couchbase", "log", "memcache", "mysql", "postgres", "rabbitmq", "redis", "rpc-client", "sqlalchemy", "soap", "tornado-client", "urllib3") + entry_spans = ("aiohttp-server", "django", "wsgi", "rabbitmq", "rpc-server", "tornado-server") + local_spans = ("log", "render") entry_kind = ["entry", "server", "consumer"] @@ -161,6 +164,13 @@ def build_registered_span(self, span): if data.rabbitmq.sort == 'consume': kind = 1 # entry + if span.operation_name == "couchbase": + data.couchbase = CouchbaseData(hostname=span.tags.pop('couchbase.hostname', None), + bucket=span.tags.pop('couchbase.bucket', None), + type=span.tags.pop('couchbase.type', None), + error=span.tags.pop('couchbase.error', None), + error_type=span.tags.pop('couchbase.error_type', None)) + if span.operation_name == "redis": data.redis = RedisData(connection=span.tags.pop('connection', None), driver=span.tags.pop('driver', None), diff --git a/setup.py b/setup.py index 5ba3cdc2..670bd28c 100644 --- a/setup.py +++ b/setup.py @@ -69,6 +69,7 @@ def check_setuptools(): 'test': [ 'aiohttp>=3.5.4;python_version>="3.5"', 'asynqp>=0.4;python_version>="3.5"', + 'couchbase==2.5.9', 'django>=1.11,<2.2', 'nose>=1.0', 'flask>=0.12.2', From 01363077538624e620406854edbb10d46b839aa1 Mon Sep 17 00:00:00 2001 From: Peter Giacomo Lombardo Date: Tue, 26 Nov 2019 17:03:04 +0100 Subject: [PATCH 02/12] Initial couchbase instrumentation --- instana/__init__.py | 1 + instana/instrumentation/couchbase_inst.py | 45 ++ tests/helpers.py | 7 + tests/test_couchbase.py | 547 ++++++++++++++++++++++ 4 files changed, 600 insertions(+) create mode 100644 instana/instrumentation/couchbase_inst.py create mode 100644 tests/test_couchbase.py diff --git a/instana/__init__.py b/instana/__init__.py index de4e484a..476e0df0 100644 --- a/instana/__init__.py +++ b/instana/__init__.py @@ -67,6 +67,7 @@ def boot_agent(): else: from .instrumentation import mysqlclient + from .instrumentation import couchbase_inst from .instrumentation import flask from .instrumentation import grpcio from .instrumentation.tornado import client diff --git a/instana/instrumentation/couchbase_inst.py b/instana/instrumentation/couchbase_inst.py new file mode 100644 index 00000000..d1b09bb5 --- /dev/null +++ b/instana/instrumentation/couchbase_inst.py @@ -0,0 +1,45 @@ +from __future__ import absolute_import + +import wrapt +import opentracing + +from ..log import logger +from ..singletons import tracer + +try: + import couchbase + + def make_wrapper(op): + def wrapper(wrapped, instance, args, kwargs): + parent_span = tracer.active_span + + # If we're not tracing, just return + if parent_span is None: + return wrapped(*args, **kwargs) + + with tracer.start_active_span("couchbase", child_of=parent_span) as scope: + 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) + return wrapped(*args, **kwargs) + except Exception as e: + scope.span.log_exception(e) + scope.span.set_tag('couchbase.error', repr(e)) + raise + return wrapper + + operations = ['upsert', 'insert', 'replace', 'append', 'prepend', 'get', 'touch', 'lock', + 'unlock', 'remove', 'counter', 'mutate_in', 'lookup_in', 'retrieve_in', 'incr', + 'incr_multi', 'decr', 'decr_multi', 'stats', 'ping', 'diagnostics', 'observe', + 'endure', 'durability', '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', 'rget', 'rget_multi'] + + for op in operations: + f = make_wrapper(op) + wrapt.wrap_function_wrapper('couchbase.bucket', 'Bucket.%s' % op, f) + + logger.debug("Instrumenting couchbase") +except ImportError: + pass \ No newline at end of file diff --git a/tests/helpers.py b/tests/helpers.py index a48de128..68d0bf8b 100644 --- a/tests/helpers.py +++ b/tests/helpers.py @@ -2,6 +2,13 @@ testenv = {} +""" +CouchDB Environment +""" +testenv['couchdb_host'] = os.environ.get('COUCHDB_HOST', '127.0.0.1') +testenv['couchdb_username'] = os.environ.get('COUCHDB_USERNAME', 'Administrator') +testenv['couchdb_password'] = os.environ.get('COUCHDB_PASSWORD', '') + """ MySQL Environment """ diff --git a/tests/test_couchbase.py b/tests/test_couchbase.py new file mode 100644 index 00000000..f1cf245c --- /dev/null +++ b/tests/test_couchbase.py @@ -0,0 +1,547 @@ +from __future__ import absolute_import + +import unittest + +import requests +import urllib3 + +from instana.singletons import tracer +from .helpers import testenv, get_first_span_by_name, get_span_by_filter + +from couchbase.bucket import Bucket +from couchbase.exceptions import KeyExistsError, NotFoundError + + +class TestStandardCouchDB(unittest.TestCase): + def setUp(self): + """ Clear all spans before a test run """ + self.recorder = tracer.recorder + self.recorder.clear_spans() + self.bucket = Bucket('couchbase://mazzo/beer-sample', username='test', password='testtest') + + def tearDown(self): + """ Do nothing for now """ + return None + + def test_vanilla_get(self): + res = self.bucket.get("21st_amendment_brewery_cafe") + self.assertIsNotNone(res) + + def test_pipeline(self): + pass + + def test_upsert(self): + res = None + with tracer.start_active_span('test'): + res = self.bucket.upsert("test_upsert", 1) + + self.assertIsNotNone(res) + self.assertTrue(res.success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'upsert') + + def test_insert_new(self): + res = None + try: + self.bucket.remove('test_insert_new') + except NotFoundError: + pass + + with tracer.start_active_span('test'): + res = self.bucket.insert("test_insert_new", 1) + + self.assertIsNotNone(res) + self.assertTrue(res.success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'insert') + + def test_insert_existing(self): + res = None + try: + self.bucket.insert("test_insert", 1) + except KeyExistsError: + pass + + try: + with tracer.start_active_span('test'): + res = self.bucket.insert("test_insert", 1) + except KeyExistsError: + pass + + self.assertIsNone(res) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertTrue(cb_span.error) + self.assertEqual(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.") + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'insert') + + def test_replace(self): + res = None + try: + self.bucket.insert("test_replace", 1) + except KeyExistsError: + pass + + with tracer.start_active_span('test'): + res = self.bucket.replace("test_replace", 2) + + self.assertIsNotNone(res) + self.assertTrue(res.success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'replace') + + def test_replace_non_existent(self): + res = None + + try: + self.bucket.remove("test_replace") + except NotFoundError: + pass + + try: + with tracer.start_active_span('test'): + res = self.bucket.replace("test_replace", 2) + except NotFoundError: + pass + + self.assertIsNone(res) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertTrue(cb_span.error) + self.assertEqual(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.") + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'replace') + + def test_append(self): + self.bucket.upsert("test_append", "one") + + res = None + with tracer.start_active_span('test'): + res = self.bucket.append("test_append", "two") + + self.assertIsNotNone(res) + self.assertTrue(res.success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'append') + + def test_prepend(self): + self.bucket.upsert("test_prepend", "one") + + res = None + with tracer.start_active_span('test'): + res = self.bucket.prepend("test_prepend", "two") + + self.assertIsNotNone(res) + self.assertTrue(res.success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'prepend') + + def test_get(self): + res = None + + with tracer.start_active_span('test'): + res = self.bucket.get("21st_amendment_brewery_cafe") + + self.assertIsNotNone(res) + self.assertTrue(res.success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'get') + + def test_get_not_found(self): + res = None + try: + self.bucket.remove('test_get_not_found') + except NotFoundError: + pass + + try: + with tracer.start_active_span('test'): + res = self.bucket.get("test_get_not_found") + except NotFoundError: + pass + + self.assertIsNone(res) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertTrue(cb_span.error) + self.assertEqual(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.") + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'get') + + def test_touch(self): + res = None + self.bucket.upsert("test_touch", 1) + + with tracer.start_active_span('test'): + res = self.bucket.touch("test_touch") + + self.assertIsNotNone(res) + self.assertTrue(res.success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'touch') + + def test_lock(self): + res = None + self.bucket.upsert("test_lock_unlock", "lock_this") + + with tracer.start_active_span('test'): + rv = self.bucket.lock("test_lock_unlock", ttl=5) + self.assertIsNotNone(rv) + self.assertTrue(rv.success) + + # upsert automatically unlocks the key + res = self.bucket.upsert("test_lock_unlock", "updated", rv.cas) + self.assertIsNotNone(res) + self.assertTrue(res.success) + + spans = self.recorder.queued_spans() + self.assertEqual(3, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + filter = lambda span: span.n == "couchbase" and span.data.couchbase.type == "lock" + cb_lock_span = get_span_by_filter(spans, filter) + self.assertIsNotNone(cb_lock_span) + + filter = lambda span: span.n == "couchbase" and span.data.couchbase.type == "upsert" + cb_upsert_span = get_span_by_filter(spans, filter) + self.assertIsNotNone(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.assertIsNotNone(cb_lock_span.stack) + self.assertFalse(cb_lock_span.error) + self.assertIsNone(cb_lock_span.ec) + self.assertIsNotNone(cb_upsert_span.stack) + self.assertFalse(cb_upsert_span.error) + self.assertIsNone(cb_upsert_span.ec) + + self.assertEqual(cb_lock_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_lock_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_lock_span.data.couchbase.type, 'lock') + self.assertEqual(cb_upsert_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_upsert_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_upsert_span.data.couchbase.type, 'upsert') + + def test_lock_unlock(self): + res = None + self.bucket.upsert("test_lock_unlock", "lock_this") + + with tracer.start_active_span('test'): + rv = self.bucket.lock("test_lock_unlock", ttl=5) + self.assertIsNotNone(rv) + self.assertTrue(rv.success) + + # upsert automatically unlocks the key + res = self.bucket.unlock("test_lock_unlock", rv.cas) + self.assertIsNotNone(res) + self.assertTrue(res.success) + + spans = self.recorder.queued_spans() + self.assertEqual(3, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + filter = lambda span: span.n == "couchbase" and span.data.couchbase.type == "lock" + cb_lock_span = get_span_by_filter(spans, filter) + self.assertIsNotNone(cb_lock_span) + + filter = lambda span: span.n == "couchbase" and span.data.couchbase.type == "unlock" + cb_unlock_span = get_span_by_filter(spans, filter) + self.assertIsNotNone(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.assertIsNotNone(cb_lock_span.stack) + self.assertFalse(cb_lock_span.error) + self.assertIsNone(cb_lock_span.ec) + self.assertIsNotNone(cb_unlock_span.stack) + self.assertFalse(cb_unlock_span.error) + self.assertIsNone(cb_unlock_span.ec) + + self.assertEqual(cb_lock_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_lock_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_lock_span.data.couchbase.type, 'lock') + self.assertEqual(cb_unlock_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_unlock_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_unlock_span.data.couchbase.type, 'unlock') + + def test_remove(self): + res = None + self.bucket.upsert("test_remove", 1) + + with tracer.start_active_span('test'): + res = self.bucket.remove("test_remove") + + self.assertIsNotNone(res) + self.assertTrue(res.success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'remove') + + def test_counter(self): + res = None + self.bucket.upsert("test_counter", 1) + + with tracer.start_active_span('test'): + res = self.bucket.counter("test_counter", delta=10) + + self.assertIsNotNone(res) + self.assertTrue(res.success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'counter') + + + + From ce6ce0175896a93d8bcb1d4e67936792c3ecd6ac Mon Sep 17 00:00:00 2001 From: Peter Giacomo Lombardo Date: Wed, 27 Nov 2019 16:04:05 +0100 Subject: [PATCH 03/12] Instrument all the ops & many more tests. --- instana/instrumentation/couchbase_inst.py | 40 +- instana/json_span.py | 1 + instana/recorder.py | 3 +- tests/test_couchbase.py | 706 +++++++++++++++++++++- 4 files changed, 728 insertions(+), 22 deletions(-) diff --git a/instana/instrumentation/couchbase_inst.py b/instana/instrumentation/couchbase_inst.py index d1b09bb5..dec30e76 100644 --- a/instana/instrumentation/couchbase_inst.py +++ b/instana/instrumentation/couchbase_inst.py @@ -1,3 +1,7 @@ +""" +couchbase instrumentation - This instrumentation supports the Python CouchBase 2.5 SDK only currently: +https://docs.couchbase.com/python-sdk/2.5/start-using-sdk.html +""" from __future__ import absolute_import import wrapt @@ -29,17 +33,41 @@ def wrapper(wrapped, instance, args, kwargs): raise return wrapper - operations = ['upsert', 'insert', 'replace', 'append', 'prepend', 'get', 'touch', 'lock', - 'unlock', 'remove', 'counter', 'mutate_in', 'lookup_in', 'retrieve_in', 'incr', - 'incr_multi', 'decr', 'decr_multi', 'stats', 'ping', 'diagnostics', 'observe', - 'endure', 'durability', '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', 'rget', 'rget_multi'] + # 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 query_with_instana(wrapped, instance, args, kwargs): + parent_span = tracer.active_span + + # If we're not tracing, just return + if parent_span is None: + return wrapped(*args, **kwargs) + + with tracer.start_active_span("couchbase", child_of=parent_span) as scope: + 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', 'n1ql_query') + scope.span.set_tag('couchbase.q', args[0]) + return wrapped(*args, **kwargs) + except Exception as e: + scope.span.log_exception(e) + scope.span.set_tag('couchbase.error', repr(e)) + raise for op in operations: f = make_wrapper(op) wrapt.wrap_function_wrapper('couchbase.bucket', 'Bucket.%s' % op, f) + wrapt.wrap_function_wrapper('couchbase.bucket', 'Bucket.n1ql_query', query_with_instana) + logger.debug("Instrumenting couchbase") except ImportError: pass \ No newline at end of file diff --git a/instana/json_span.py b/instana/json_span.py index db4fd523..7ab9681b 100644 --- a/instana/json_span.py +++ b/instana/json_span.py @@ -54,6 +54,7 @@ class CouchbaseData(BaseSpan): type = None error = None error_code = None + q = None class HttpData(BaseSpan): diff --git a/instana/recorder.py b/instana/recorder.py index cd744503..a13ce5ca 100644 --- a/instana/recorder.py +++ b/instana/recorder.py @@ -169,7 +169,8 @@ def build_registered_span(self, span): bucket=span.tags.pop('couchbase.bucket', None), type=span.tags.pop('couchbase.type', None), error=span.tags.pop('couchbase.error', None), - error_type=span.tags.pop('couchbase.error_type', None)) + error_type=span.tags.pop('couchbase.error_type', None), + q=span.tags.pop('couchbase.q', None)) if span.operation_name == "redis": data.redis = RedisData(connection=span.tags.pop('connection', None), diff --git a/tests/test_couchbase.py b/tests/test_couchbase.py index f1cf245c..e528a426 100644 --- a/tests/test_couchbase.py +++ b/tests/test_couchbase.py @@ -9,7 +9,8 @@ from .helpers import testenv, get_first_span_by_name, get_span_by_filter from couchbase.bucket import Bucket -from couchbase.exceptions import KeyExistsError, NotFoundError +from couchbase.exceptions import CouchbaseTransientError, KeyExistsError, NotFoundError +import couchbase.subdocument as SD class TestStandardCouchDB(unittest.TestCase): @@ -60,6 +61,42 @@ def test_upsert(self): self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') self.assertEqual(cb_span.data.couchbase.type, 'upsert') + def test_upsert_multi(self): + res = None + + kvs = dict() + kvs['first_test_upsert_multi'] = 1 + kvs['second_test_upsert_multi'] = 1 + + with tracer.start_active_span('test'): + res = self.bucket.upsert_multi(kvs) + + self.assertIsNotNone(res) + self.assertTrue(res['first_test_upsert_multi'].success) + self.assertTrue(res['second_test_upsert_multi'].success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'upsert_multi') + def test_insert_new(self): res = None try: @@ -135,6 +172,45 @@ def test_insert_existing(self): self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') self.assertEqual(cb_span.data.couchbase.type, 'insert') + def test_insert_multi(self): + res = None + + kvs = dict() + kvs['first_test_upsert_multi'] = 1 + kvs['second_test_upsert_multi'] = 1 + + self.bucket.remove('first_test_upsert_multi') + self.bucket.remove('second_test_upsert_multi') + + with tracer.start_active_span('test'): + res = self.bucket.insert_multi(kvs) + + self.assertIsNotNone(res) + self.assertTrue(res['first_test_upsert_multi'].success) + self.assertTrue(res['second_test_upsert_multi'].success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'insert_multi') + def test_replace(self): res = None try: @@ -211,6 +287,45 @@ def test_replace_non_existent(self): self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') self.assertEqual(cb_span.data.couchbase.type, 'replace') + def test_replace_multi(self): + res = None + + kvs = dict() + 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") + + with tracer.start_active_span('test'): + res = self.bucket.replace_multi(kvs) + + self.assertIsNotNone(res) + self.assertTrue(res['first_test_replace_multi'].success) + self.assertTrue(res['second_test_replace_multi'].success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'replace_multi') + def test_append(self): self.bucket.upsert("test_append", "one") @@ -243,6 +358,45 @@ def test_append(self): self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') self.assertEqual(cb_span.data.couchbase.type, 'append') + def test_append_multi(self): + res = None + + kvs = dict() + 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") + + with tracer.start_active_span('test'): + res = self.bucket.append_multi(kvs) + + self.assertIsNotNone(res) + self.assertTrue(res['first_test_append_multi'].success) + self.assertTrue(res['second_test_append_multi'].success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'append_multi') + def test_prepend(self): self.bucket.upsert("test_prepend", "one") @@ -275,6 +429,45 @@ def test_prepend(self): self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') self.assertEqual(cb_span.data.couchbase.type, 'prepend') + def test_prepend_multi(self): + res = None + + kvs = dict() + 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") + + with tracer.start_active_span('test'): + res = self.bucket.prepend_multi(kvs) + + self.assertIsNotNone(res) + self.assertTrue(res['first_test_prepend_multi'].success) + self.assertTrue(res['second_test_prepend_multi'].success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'prepend_multi') + def test_get(self): res = None @@ -306,6 +499,42 @@ def test_get(self): self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') self.assertEqual(cb_span.data.couchbase.type, 'get') + def test_rget(self): + res = None + + try: + with tracer.start_active_span('test'): + res = self.bucket.rget("21st_amendment_brewery_cafe", replica_index=None) + except CouchbaseTransientError: + pass + + self.assertIsNone(res) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertTrue(cb_span.error) + self.assertEqual(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.") + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'rget') + def test_get_not_found(self): res = None try: @@ -346,6 +575,41 @@ def test_get_not_found(self): self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') self.assertEqual(cb_span.data.couchbase.type, 'get') + def test_get_multi(self): + res = None + + 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']) + + self.assertIsNotNone(res) + self.assertTrue(res['first_test_get_multi'].success) + self.assertTrue(res['second_test_get_multi'].success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'get_multi') + def test_touch(self): res = None self.bucket.upsert("test_touch", 1) @@ -378,6 +642,41 @@ def test_touch(self): self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') self.assertEqual(cb_span.data.couchbase.type, 'touch') + def test_touch_multi(self): + res = None + + 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']) + + self.assertIsNotNone(res) + self.assertTrue(res['first_test_touch_multi'].success) + self.assertTrue(res['second_test_touch_multi'].success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'touch_multi') + def test_lock(self): res = None self.bucket.upsert("test_lock_unlock", "lock_this") @@ -478,38 +777,126 @@ def test_lock_unlock(self): self.assertEqual(cb_unlock_span.data.couchbase.bucket, 'beer-sample') self.assertEqual(cb_unlock_span.data.couchbase.type, 'unlock') - def test_remove(self): + def test_lock_unlock_muilti(self): res = None - self.bucket.upsert("test_remove", 1) + 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'): - res = self.bucket.remove("test_remove") + rv = self.bucket.lock_multi(keys_to_lock, ttl=5) + self.assertIsNotNone(rv) + self.assertTrue(rv['test_lock_unlock_multi_1'].success) + self.assertTrue(rv['test_lock_unlock_multi_2'].success) - self.assertIsNotNone(res) - self.assertTrue(res.success) + res = self.bucket.unlock_multi(rv) + self.assertIsNotNone(res) spans = self.recorder.queued_spans() - self.assertEqual(2, len(spans)) + self.assertEqual(3, len(spans)) test_span = get_first_span_by_name(spans, 'sdk') self.assertIsNotNone(test_span) self.assertEqual(test_span.data.sdk.name, 'test') - cb_span = get_first_span_by_name(spans, 'couchbase') - self.assertIsNotNone(cb_span) + filter = lambda span: span.n == "couchbase" and span.data.couchbase.type == "lock_multi" + cb_lock_span = get_span_by_filter(spans, filter) + self.assertIsNotNone(cb_lock_span) - # Same traceId and parent relationship - self.assertEqual(test_span.t, cb_span.t) - self.assertEqual(cb_span.p, test_span.s) + filter = lambda span: span.n == "couchbase" and span.data.couchbase.type == "unlock_multi" + cb_unlock_span = get_span_by_filter(spans, filter) + self.assertIsNotNone(cb_unlock_span) - self.assertIsNotNone(cb_span.stack) - self.assertFalse(cb_span.error) - self.assertIsNone(cb_span.ec) + # 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.assertIsNotNone(cb_lock_span.stack) + self.assertFalse(cb_lock_span.error) + self.assertIsNone(cb_lock_span.ec) + self.assertIsNotNone(cb_unlock_span.stack) + self.assertFalse(cb_unlock_span.error) + self.assertIsNone(cb_unlock_span.ec) + + self.assertEqual(cb_lock_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_lock_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_lock_span.data.couchbase.type, 'lock_multi') + self.assertEqual(cb_unlock_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_unlock_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_unlock_span.data.couchbase.type, 'unlock_multi') + + def test_remove(self): + res = None + self.bucket.upsert("test_remove", 1) + + with tracer.start_active_span('test'): + res = self.bucket.remove("test_remove") + + self.assertIsNotNone(res) + self.assertTrue(res.success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') self.assertEqual(cb_span.data.couchbase.type, 'remove') + def test_remove_multi(self): + 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'): + res = self.bucket.remove_multi(keys_to_remove) + + self.assertIsNotNone(res) + self.assertTrue(res['test_remove_multi_1'].success) + self.assertTrue(res['test_remove_multi_2'].success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'remove_multi') + def test_counter(self): res = None self.bucket.upsert("test_counter", 1) @@ -542,6 +929,295 @@ def test_counter(self): self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') self.assertEqual(cb_span.data.couchbase.type, 'counter') + def test_counter_multi(self): + 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")) + + self.assertIsNotNone(res) + self.assertTrue(res['first_test_counter'].success) + self.assertTrue(res['second_test_counter'].success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'counter_multi') + + def test_mutate_in(self): + 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.assertIsNotNone(res) + self.assertTrue(res.success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'mutate_in') + + def test_lookup_in(self): + 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.assertIsNotNone(res) + self.assertTrue(res.success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'lookup_in') + + def test_stats(self): + res = None + + with tracer.start_active_span('test'): + res = self.bucket.stats() + + self.assertIsNotNone(res) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'stats') + + def test_ping(self): + res = None + + with tracer.start_active_span('test'): + res = self.bucket.ping() + + self.assertIsNotNone(res) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'ping') + + def test_diagnostics(self): + res = None + + with tracer.start_active_span('test'): + res = self.bucket.diagnostics() + + self.assertIsNotNone(res) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'diagnostics') + + def test_observe(self): + res = None + self.bucket.upsert('test_observe', 1) + + with tracer.start_active_span('test'): + res = self.bucket.observe('test_observe') + self.assertIsNotNone(res) + self.assertTrue(res.success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'observe') + + def test_observe_multi(self): + res = None + 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') + + with tracer.start_active_span('test'): + res = self.bucket.observe_multi(keys_to_observe) + + self.assertIsNotNone(res) + self.assertTrue(res['test_observe_multi_1'].success) + self.assertTrue(res['test_observe_multi_2'].success) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'observe_multi') + + def test_n1ql_query(self): + res = None + + with tracer.start_active_span('test'): + res = self.bucket.n1ql_query("SELECT 1") + + self.assertIsNotNone(res) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + self.assertIsNone(cb_span.ec) + + self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.type, 'n1ql_query') + self.assertEqual(cb_span.data.couchbase.q, 'SELECT 1') From c0d311bf20d92bab0495f51e04e0b2f611722747 Mon Sep 17 00:00:00 2001 From: Peter Giacomo Lombardo Date: Thu, 28 Nov 2019 13:16:17 +0100 Subject: [PATCH 04/12] Update sql field name --- instana/instrumentation/couchbase_inst.py | 2 +- instana/json_span.py | 2 +- instana/recorder.py | 2 +- tests/test_couchbase.py | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/instana/instrumentation/couchbase_inst.py b/instana/instrumentation/couchbase_inst.py index dec30e76..bde7dcd6 100644 --- a/instana/instrumentation/couchbase_inst.py +++ b/instana/instrumentation/couchbase_inst.py @@ -55,7 +55,7 @@ def query_with_instana(wrapped, instance, args, kwargs): scope.span.set_tag('couchbase.hostname', instance.server_nodes[0]) scope.span.set_tag('couchbase.bucket', instance.bucket) scope.span.set_tag('couchbase.type', 'n1ql_query') - scope.span.set_tag('couchbase.q', args[0]) + scope.span.set_tag('couchbase.sql', args[0]) return wrapped(*args, **kwargs) except Exception as e: scope.span.log_exception(e) diff --git a/instana/json_span.py b/instana/json_span.py index 7ab9681b..fab4154b 100644 --- a/instana/json_span.py +++ b/instana/json_span.py @@ -54,7 +54,7 @@ class CouchbaseData(BaseSpan): type = None error = None error_code = None - q = None + sql = None class HttpData(BaseSpan): diff --git a/instana/recorder.py b/instana/recorder.py index a13ce5ca..238d3892 100644 --- a/instana/recorder.py +++ b/instana/recorder.py @@ -170,7 +170,7 @@ def build_registered_span(self, span): type=span.tags.pop('couchbase.type', None), error=span.tags.pop('couchbase.error', None), error_type=span.tags.pop('couchbase.error_type', None), - q=span.tags.pop('couchbase.q', None)) + sql=span.tags.pop('couchbase.sql', None)) if span.operation_name == "redis": data.redis = RedisData(connection=span.tags.pop('connection', None), diff --git a/tests/test_couchbase.py b/tests/test_couchbase.py index e528a426..7747f62c 100644 --- a/tests/test_couchbase.py +++ b/tests/test_couchbase.py @@ -1220,4 +1220,4 @@ def test_n1ql_query(self): self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') self.assertEqual(cb_span.data.couchbase.type, 'n1ql_query') - self.assertEqual(cb_span.data.couchbase.q, 'SELECT 1') + self.assertEqual(cb_span.data.couchbase.sql, 'SELECT 1') From 7b887b2a6e90c009520ff15892ad5556306f7dae Mon Sep 17 00:00:00 2001 From: Peter Giacomo Lombardo Date: Fri, 29 Nov 2019 14:45:13 +0100 Subject: [PATCH 05/12] Generalize test env for CircleCI --- tests/helpers.py | 4 +- tests/test_couchbase.py | 107 +++++++++++++++++++++++----------------- 2 files changed, 63 insertions(+), 48 deletions(-) diff --git a/tests/helpers.py b/tests/helpers.py index 68d0bf8b..77efa536 100644 --- a/tests/helpers.py +++ b/tests/helpers.py @@ -6,8 +6,8 @@ CouchDB Environment """ testenv['couchdb_host'] = os.environ.get('COUCHDB_HOST', '127.0.0.1') -testenv['couchdb_username'] = os.environ.get('COUCHDB_USERNAME', 'Administrator') -testenv['couchdb_password'] = os.environ.get('COUCHDB_PASSWORD', '') +testenv['couchdb_username'] = os.environ.get('COUCHDB_USERNAME', 'test') +testenv['couchdb_password'] = os.environ.get('COUCHDB_PASSWORD', 'testtest') """ MySQL Environment diff --git a/tests/test_couchbase.py b/tests/test_couchbase.py index 7747f62c..de6b5021 100644 --- a/tests/test_couchbase.py +++ b/tests/test_couchbase.py @@ -2,30 +2,42 @@ import unittest -import requests -import urllib3 - from instana.singletons import tracer from .helpers import testenv, get_first_span_by_name, get_span_by_filter +from couchbase.admin import Admin +from couchbase.cluster import Cluster from couchbase.bucket import Bucket -from couchbase.exceptions import CouchbaseTransientError, KeyExistsError, NotFoundError +from couchbase.exceptions import CouchbaseTransientError, HTTPError, KeyExistsError, NotFoundError import couchbase.subdocument as SD +# Delete any pre-existing buckets. Create new. +cb_adm = Admin('Administrator', testenv['couchdb_password'], host=testenv['couchdb_host'], port=8091) + +# Make sure a test bucket exists +try: + cb_adm.bucket_create('instana-test') + cb_adm.wait_ready('instana-test', timeout=30) +except HTTPError: + pass + class TestStandardCouchDB(unittest.TestCase): def setUp(self): """ Clear all spans before a test run """ self.recorder = tracer.recorder self.recorder.clear_spans() - self.bucket = Bucket('couchbase://mazzo/beer-sample', username='test', password='testtest') + self.cluster = Cluster('couchbase://%s' % testenv['couchdb_host']) + self.bucket = Bucket('couchbase://%s/instana-test' % testenv['couchdb_host'], + username=testenv['couchdb_username'], password=testenv['couchdb_password']) + self.bucket.upsert('test-key', 1) def tearDown(self): """ Do nothing for now """ return None def test_vanilla_get(self): - res = self.bucket.get("21st_amendment_brewery_cafe") + res = self.bucket.get("test-key") self.assertIsNotNone(res) def test_pipeline(self): @@ -58,7 +70,7 @@ def test_upsert(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'upsert') def test_upsert_multi(self): @@ -94,7 +106,7 @@ def test_upsert_multi(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'upsert_multi') def test_insert_new(self): @@ -129,7 +141,7 @@ def test_insert_new(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'insert') def test_insert_existing(self): @@ -169,7 +181,7 @@ def test_insert_existing(self): self.assertFalse(found == -1, "Error substring not found.") self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'insert') def test_insert_multi(self): @@ -179,8 +191,11 @@ def test_insert_multi(self): kvs['first_test_upsert_multi'] = 1 kvs['second_test_upsert_multi'] = 1 - self.bucket.remove('first_test_upsert_multi') - self.bucket.remove('second_test_upsert_multi') + try: + self.bucket.remove('first_test_upsert_multi') + self.bucket.remove('second_test_upsert_multi') + except NotFoundError: + pass with tracer.start_active_span('test'): res = self.bucket.insert_multi(kvs) @@ -208,7 +223,7 @@ def test_insert_multi(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'insert_multi') def test_replace(self): @@ -243,7 +258,7 @@ def test_replace(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'replace') def test_replace_non_existent(self): @@ -284,7 +299,7 @@ def test_replace_non_existent(self): self.assertFalse(found == -1, "Error substring not found.") self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'replace') def test_replace_multi(self): @@ -323,7 +338,7 @@ def test_replace_multi(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'replace_multi') def test_append(self): @@ -355,7 +370,7 @@ def test_append(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'append') def test_append_multi(self): @@ -394,7 +409,7 @@ def test_append_multi(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'append_multi') def test_prepend(self): @@ -426,7 +441,7 @@ def test_prepend(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'prepend') def test_prepend_multi(self): @@ -465,14 +480,14 @@ def test_prepend_multi(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'prepend_multi') def test_get(self): res = None with tracer.start_active_span('test'): - res = self.bucket.get("21st_amendment_brewery_cafe") + res = self.bucket.get("test-key") self.assertIsNotNone(res) self.assertTrue(res.success) @@ -496,7 +511,7 @@ def test_get(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'get') def test_rget(self): @@ -504,7 +519,7 @@ def test_rget(self): try: with tracer.start_active_span('test'): - res = self.bucket.rget("21st_amendment_brewery_cafe", replica_index=None) + res = self.bucket.rget("test-key", replica_index=None) except CouchbaseTransientError: pass @@ -532,7 +547,7 @@ def test_rget(self): self.assertFalse(found == -1, "Error substring not found.") self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'rget') def test_get_not_found(self): @@ -572,7 +587,7 @@ def test_get_not_found(self): self.assertFalse(found == -1, "Error substring not found.") self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'get') def test_get_multi(self): @@ -607,7 +622,7 @@ def test_get_multi(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'get_multi') def test_touch(self): @@ -639,7 +654,7 @@ def test_touch(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'touch') def test_touch_multi(self): @@ -674,7 +689,7 @@ def test_touch_multi(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'touch_multi') def test_lock(self): @@ -721,10 +736,10 @@ def test_lock(self): self.assertIsNone(cb_upsert_span.ec) self.assertEqual(cb_lock_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_lock_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_lock_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_lock_span.data.couchbase.type, 'lock') self.assertEqual(cb_upsert_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_upsert_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_upsert_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_upsert_span.data.couchbase.type, 'upsert') def test_lock_unlock(self): @@ -771,10 +786,10 @@ def test_lock_unlock(self): self.assertIsNone(cb_unlock_span.ec) self.assertEqual(cb_lock_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_lock_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_lock_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_lock_span.data.couchbase.type, 'lock') self.assertEqual(cb_unlock_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_unlock_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_unlock_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_unlock_span.data.couchbase.type, 'unlock') def test_lock_unlock_muilti(self): @@ -823,10 +838,10 @@ def test_lock_unlock_muilti(self): self.assertIsNone(cb_unlock_span.ec) self.assertEqual(cb_lock_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_lock_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_lock_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_lock_span.data.couchbase.type, 'lock_multi') self.assertEqual(cb_unlock_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_unlock_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_unlock_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_unlock_span.data.couchbase.type, 'unlock_multi') def test_remove(self): @@ -858,7 +873,7 @@ def test_remove(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'remove') def test_remove_multi(self): @@ -894,7 +909,7 @@ def test_remove_multi(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'remove_multi') def test_counter(self): @@ -926,7 +941,7 @@ def test_counter(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'counter') def test_counter_multi(self): @@ -960,7 +975,7 @@ def test_counter_multi(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'counter_multi') def test_mutate_in(self): @@ -995,7 +1010,7 @@ def test_mutate_in(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'mutate_in') def test_lookup_in(self): @@ -1030,7 +1045,7 @@ def test_lookup_in(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'lookup_in') def test_stats(self): @@ -1060,7 +1075,7 @@ def test_stats(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'stats') def test_ping(self): @@ -1090,7 +1105,7 @@ def test_ping(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'ping') def test_diagnostics(self): @@ -1120,7 +1135,7 @@ def test_diagnostics(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'diagnostics') def test_observe(self): @@ -1152,7 +1167,7 @@ def test_observe(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'observe') def test_observe_multi(self): @@ -1188,7 +1203,7 @@ def test_observe_multi(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'observe_multi') def test_n1ql_query(self): @@ -1218,6 +1233,6 @@ def test_n1ql_query(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'beer-sample') + self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') self.assertEqual(cb_span.data.couchbase.type, 'n1ql_query') self.assertEqual(cb_span.data.couchbase.sql, 'SELECT 1') From 7ed8de8401ffc063d7086105960eeef8d8af503b Mon Sep 17 00:00:00 2001 From: Peter Giacomo Lombardo Date: Fri, 29 Nov 2019 16:43:26 +0100 Subject: [PATCH 06/12] Install couchbase dev package for py package --- .circleci/config.yml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.circleci/config.yml b/.circleci/config.yml index b9a70755..3e095ab9 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -132,6 +132,12 @@ jobs: - run: name: install dependencies command: | + sudo apt-get update + sudo apt install lsb-release -y + curl -O https://packages.couchbase.com/releases/couchbase-release/couchbase-release-1.0-6-amd64.deb + sudo dpkg -i ./couchbase-release-1.0-6-amd64.deb + sudo apt-get update + sudo apt install libcouchbase-dev -y python -m venv venv . venv/bin/activate pip install -U pip From eddee4ad2d01dd69c47669a96a152bba8bcd1993 Mon Sep 17 00:00:00 2001 From: Peter Giacomo Lombardo Date: Mon, 2 Dec 2019 11:31:49 +0100 Subject: [PATCH 07/12] Switch to couchbase server sandbox for tests --- .circleci/config.yml | 1 + tests/helpers.py | 4 +- tests/test_couchbase.py | 81 +++++++++++++++++++++-------------------- 3 files changed, 44 insertions(+), 42 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 3e095ab9..7f0b1fb9 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -116,6 +116,7 @@ jobs: - image: circleci/redis:5.0.4 - image: rabbitmq:3.5.4 - image: couchbase:6.0.3 + - image: couchbase/server-sandbox:5.5.0 working_directory: ~/repo diff --git a/tests/helpers.py b/tests/helpers.py index 77efa536..a6956b36 100644 --- a/tests/helpers.py +++ b/tests/helpers.py @@ -6,8 +6,8 @@ CouchDB Environment """ testenv['couchdb_host'] = os.environ.get('COUCHDB_HOST', '127.0.0.1') -testenv['couchdb_username'] = os.environ.get('COUCHDB_USERNAME', 'test') -testenv['couchdb_password'] = os.environ.get('COUCHDB_PASSWORD', 'testtest') +testenv['couchdb_username'] = os.environ.get('COUCHDB_USERNAME', 'Administrator') +testenv['couchdb_password'] = os.environ.get('COUCHDB_PASSWORD', 'password') """ MySQL Environment diff --git a/tests/test_couchbase.py b/tests/test_couchbase.py index de6b5021..bf9f4153 100644 --- a/tests/test_couchbase.py +++ b/tests/test_couchbase.py @@ -12,12 +12,12 @@ import couchbase.subdocument as SD # Delete any pre-existing buckets. Create new. -cb_adm = Admin('Administrator', 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('instana-test') - cb_adm.wait_ready('instana-test', timeout=30) + cb_adm.bucket_create('travel-sample') + cb_adm.wait_ready('travel-sample', timeout=30) except HTTPError: pass @@ -28,8 +28,9 @@ def setUp(self): self.recorder = tracer.recorder self.recorder.clear_spans() self.cluster = Cluster('couchbase://%s' % testenv['couchdb_host']) - self.bucket = Bucket('couchbase://%s/instana-test' % testenv['couchdb_host'], + self.bucket = Bucket('couchbase://%s/travel-sample' % testenv['couchdb_host'], username=testenv['couchdb_username'], password=testenv['couchdb_password']) + # self.bucket = self.cluster.open_bucket('travel-sample') self.bucket.upsert('test-key', 1) def tearDown(self): @@ -70,7 +71,7 @@ def test_upsert(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'upsert') def test_upsert_multi(self): @@ -106,7 +107,7 @@ def test_upsert_multi(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'upsert_multi') def test_insert_new(self): @@ -141,7 +142,7 @@ def test_insert_new(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'insert') def test_insert_existing(self): @@ -181,7 +182,7 @@ def test_insert_existing(self): self.assertFalse(found == -1, "Error substring not found.") self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'insert') def test_insert_multi(self): @@ -223,7 +224,7 @@ def test_insert_multi(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'insert_multi') def test_replace(self): @@ -258,7 +259,7 @@ def test_replace(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'replace') def test_replace_non_existent(self): @@ -299,7 +300,7 @@ def test_replace_non_existent(self): self.assertFalse(found == -1, "Error substring not found.") self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'replace') def test_replace_multi(self): @@ -338,7 +339,7 @@ def test_replace_multi(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'replace_multi') def test_append(self): @@ -370,7 +371,7 @@ def test_append(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'append') def test_append_multi(self): @@ -409,7 +410,7 @@ def test_append_multi(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'append_multi') def test_prepend(self): @@ -441,7 +442,7 @@ def test_prepend(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'prepend') def test_prepend_multi(self): @@ -480,7 +481,7 @@ def test_prepend_multi(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'prepend_multi') def test_get(self): @@ -511,7 +512,7 @@ def test_get(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'get') def test_rget(self): @@ -547,7 +548,7 @@ def test_rget(self): self.assertFalse(found == -1, "Error substring not found.") self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'rget') def test_get_not_found(self): @@ -587,7 +588,7 @@ def test_get_not_found(self): self.assertFalse(found == -1, "Error substring not found.") self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'get') def test_get_multi(self): @@ -622,7 +623,7 @@ def test_get_multi(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'get_multi') def test_touch(self): @@ -654,7 +655,7 @@ def test_touch(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'touch') def test_touch_multi(self): @@ -689,7 +690,7 @@ def test_touch_multi(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'touch_multi') def test_lock(self): @@ -736,10 +737,10 @@ def test_lock(self): self.assertIsNone(cb_upsert_span.ec) self.assertEqual(cb_lock_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_lock_span.data.couchbase.bucket, 'instana-test') + 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, 'mazzo:8091') - self.assertEqual(cb_upsert_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_upsert_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_upsert_span.data.couchbase.type, 'upsert') def test_lock_unlock(self): @@ -786,10 +787,10 @@ def test_lock_unlock(self): self.assertIsNone(cb_unlock_span.ec) self.assertEqual(cb_lock_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_lock_span.data.couchbase.bucket, 'instana-test') + 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, 'mazzo:8091') - self.assertEqual(cb_unlock_span.data.couchbase.bucket, 'instana-test') + 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): @@ -838,10 +839,10 @@ def test_lock_unlock_muilti(self): self.assertIsNone(cb_unlock_span.ec) self.assertEqual(cb_lock_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_lock_span.data.couchbase.bucket, 'instana-test') + 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, 'mazzo:8091') - self.assertEqual(cb_unlock_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_unlock_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_unlock_span.data.couchbase.type, 'unlock_multi') def test_remove(self): @@ -873,7 +874,7 @@ def test_remove(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'remove') def test_remove_multi(self): @@ -909,7 +910,7 @@ def test_remove_multi(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'remove_multi') def test_counter(self): @@ -941,7 +942,7 @@ def test_counter(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'counter') def test_counter_multi(self): @@ -975,7 +976,7 @@ def test_counter_multi(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'counter_multi') def test_mutate_in(self): @@ -1010,7 +1011,7 @@ def test_mutate_in(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'mutate_in') def test_lookup_in(self): @@ -1045,7 +1046,7 @@ def test_lookup_in(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'lookup_in') def test_stats(self): @@ -1075,7 +1076,7 @@ def test_stats(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'stats') def test_ping(self): @@ -1105,7 +1106,7 @@ def test_ping(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'ping') def test_diagnostics(self): @@ -1135,7 +1136,7 @@ def test_diagnostics(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'diagnostics') def test_observe(self): @@ -1167,7 +1168,7 @@ def test_observe(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'observe') def test_observe_multi(self): @@ -1203,7 +1204,7 @@ def test_observe_multi(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'observe_multi') def test_n1ql_query(self): @@ -1233,6 +1234,6 @@ def test_n1ql_query(self): self.assertIsNone(cb_span.ec) self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') - self.assertEqual(cb_span.data.couchbase.bucket, 'instana-test') + 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') From c7741fa2f4042b30454e348f920523b5577e9abd Mon Sep 17 00:00:00 2001 From: Peter Giacomo Lombardo Date: Mon, 2 Dec 2019 11:38:53 +0100 Subject: [PATCH 08/12] Use testenv vars for value comparisons --- tests/test_couchbase.py | 72 ++++++++++++++++++++--------------------- 1 file changed, 36 insertions(+), 36 deletions(-) diff --git a/tests/test_couchbase.py b/tests/test_couchbase.py index bf9f4153..daed4aac 100644 --- a/tests/test_couchbase.py +++ b/tests/test_couchbase.py @@ -70,7 +70,7 @@ def test_upsert(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -106,7 +106,7 @@ def test_upsert_multi(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -141,7 +141,7 @@ def test_insert_new(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -181,7 +181,7 @@ def test_insert_existing(self): found = cb_span.data.couchbase.error.find("_KeyExistsError") self.assertFalse(found == -1, "Error substring not found.") - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -223,7 +223,7 @@ def test_insert_multi(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -258,7 +258,7 @@ def test_replace(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -299,7 +299,7 @@ def test_replace_non_existent(self): found = cb_span.data.couchbase.error.find("NotFoundError") self.assertFalse(found == -1, "Error substring not found.") - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -338,7 +338,7 @@ def test_replace_multi(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -370,7 +370,7 @@ def test_append(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -409,7 +409,7 @@ def test_append_multi(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -441,7 +441,7 @@ def test_prepend(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -480,7 +480,7 @@ def test_prepend_multi(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -511,7 +511,7 @@ def test_get(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -547,7 +547,7 @@ def test_rget(self): found = cb_span.data.couchbase.error.find("CouchbaseTransientError") self.assertFalse(found == -1, "Error substring not found.") - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -587,7 +587,7 @@ def test_get_not_found(self): found = cb_span.data.couchbase.error.find("NotFoundError") self.assertFalse(found == -1, "Error substring not found.") - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -622,7 +622,7 @@ def test_get_multi(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -654,7 +654,7 @@ def test_touch(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -689,7 +689,7 @@ def test_touch_multi(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -736,10 +736,10 @@ def test_lock(self): self.assertFalse(cb_upsert_span.error) self.assertIsNone(cb_upsert_span.ec) - self.assertEqual(cb_lock_span.data.couchbase.hostname, 'mazzo:8091') + 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, 'mazzo:8091') + 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') @@ -786,10 +786,10 @@ def test_lock_unlock(self): self.assertFalse(cb_unlock_span.error) self.assertIsNone(cb_unlock_span.ec) - self.assertEqual(cb_lock_span.data.couchbase.hostname, 'mazzo:8091') + 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, 'mazzo:8091') + 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') @@ -838,10 +838,10 @@ def test_lock_unlock_muilti(self): self.assertFalse(cb_unlock_span.error) self.assertIsNone(cb_unlock_span.ec) - self.assertEqual(cb_lock_span.data.couchbase.hostname, 'mazzo:8091') + 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, 'mazzo:8091') + 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') @@ -873,7 +873,7 @@ def test_remove(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -909,7 +909,7 @@ def test_remove_multi(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -941,7 +941,7 @@ def test_counter(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -975,7 +975,7 @@ def test_counter_multi(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -1010,7 +1010,7 @@ def test_mutate_in(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -1045,7 +1045,7 @@ def test_lookup_in(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -1075,7 +1075,7 @@ def test_stats(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -1105,7 +1105,7 @@ def test_ping(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -1135,7 +1135,7 @@ def test_diagnostics(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -1167,7 +1167,7 @@ def test_observe(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -1203,7 +1203,7 @@ def test_observe_multi(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') @@ -1233,7 +1233,7 @@ def test_n1ql_query(self): self.assertFalse(cb_span.error) self.assertIsNone(cb_span.ec) - self.assertEqual(cb_span.data.couchbase.hostname, 'mazzo:8091') + 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') From 5f21aa6498dc5cdce09c526a60d9e2a0bb79bac3 Mon Sep 17 00:00:00 2001 From: Peter Giacomo Lombardo Date: Mon, 2 Dec 2019 11:42:24 +0100 Subject: [PATCH 09/12] Install couchbase deps for each pipeline --- .circleci/config.yml | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/.circleci/config.yml b/.circleci/config.yml index 7f0b1fb9..4e884937 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -31,6 +31,12 @@ jobs: - run: name: install dependencies command: | + sudo apt-get update + sudo apt install lsb-release -y + curl -O https://packages.couchbase.com/releases/couchbase-release/couchbase-release-1.0-6-amd64.deb + sudo dpkg -i ./couchbase-release-1.0-6-amd64.deb + sudo apt-get update + sudo apt install libcouchbase-dev -y rm -rf venv export PATH=/home/circleci/.local/bin:$PATH pip install --user -U pip setuptools virtualenv @@ -82,6 +88,12 @@ jobs: - run: name: install dependencies command: | + sudo apt-get update + sudo apt install lsb-release -y + curl -O https://packages.couchbase.com/releases/couchbase-release/couchbase-release-1.0-6-amd64.deb + sudo dpkg -i ./couchbase-release-1.0-6-amd64.deb + sudo apt-get update + sudo apt install libcouchbase-dev -y python -m venv venv . venv/bin/activate pip install -U pip From 17373a41df33c47898724a272f2c3b505b0219d2 Mon Sep 17 00:00:00 2001 From: Peter Giacomo Lombardo Date: Mon, 2 Dec 2019 11:46:23 +0100 Subject: [PATCH 10/12] Run Couchbase server sandbox in each pipeline --- .circleci/config.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 4e884937..95f93b1c 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -15,6 +15,7 @@ jobs: - image: circleci/mariadb:10.1-ram - image: circleci/redis:5.0.4 - image: rabbitmq:3.5.4 + - image: couchbase/server-sandbox:5.5.0 working_directory: ~/repo @@ -72,6 +73,7 @@ jobs: - image: circleci/mariadb:10-ram - image: circleci/redis:5.0.4 - image: rabbitmq:3.5.4 + - image: couchbase/server-sandbox:5.5.0 working_directory: ~/repo @@ -127,7 +129,6 @@ jobs: - image: circleci/mariadb:10-ram - image: circleci/redis:5.0.4 - image: rabbitmq:3.5.4 - - image: couchbase:6.0.3 - image: couchbase/server-sandbox:5.5.0 working_directory: ~/repo From 8731a1446ecefb03d9bb85917177e75d3dbe828f Mon Sep 17 00:00:00 2001 From: Peter Giacomo Lombardo Date: Mon, 2 Dec 2019 18:40:14 +0100 Subject: [PATCH 11/12] Refactor out data collection; Tranlate N1QLQuery arg type --- instana/instrumentation/couchbase_inst.py | 53 ++++++++++++++--------- tests/test_couchbase.py | 34 ++++++++++++++- 2 files changed, 66 insertions(+), 21 deletions(-) diff --git a/instana/instrumentation/couchbase_inst.py b/instana/instrumentation/couchbase_inst.py index bde7dcd6..cc18446e 100644 --- a/instana/instrumentation/couchbase_inst.py +++ b/instana/instrumentation/couchbase_inst.py @@ -5,7 +5,6 @@ from __future__ import absolute_import import wrapt -import opentracing from ..log import logger from ..singletons import tracer @@ -13,6 +12,34 @@ try: import couchbase + # 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): + 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) + + if query_arg is not None: + query = None + if type(query_arg) is couchbase.n1ql.N1QLQuery: + query = query_arg.statement + else: + query = query_arg + + scope.span.set_tag('couchbase.sql', query) + except: + # No fail on key capture - best effort + pass + def make_wrapper(op): def wrapper(wrapped, instance, args, kwargs): parent_span = tracer.active_span @@ -22,10 +49,8 @@ def wrapper(wrapped, instance, args, kwargs): return wrapped(*args, **kwargs) with tracer.start_active_span("couchbase", child_of=parent_span) as scope: + capture_kvs(scope, instance, None, op) 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) return wrapped(*args, **kwargs) except Exception as e: scope.span.log_exception(e) @@ -33,16 +58,6 @@ def wrapper(wrapped, instance, args, kwargs): raise return wrapper - # 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 query_with_instana(wrapped, instance, args, kwargs): parent_span = tracer.active_span @@ -51,23 +66,21 @@ def query_with_instana(wrapped, instance, args, kwargs): return wrapped(*args, **kwargs) with tracer.start_active_span("couchbase", child_of=parent_span) as scope: + capture_kvs(scope, instance, args[0], 'n1ql_query') 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', 'n1ql_query') - scope.span.set_tag('couchbase.sql', args[0]) return wrapped(*args, **kwargs) except Exception as e: scope.span.log_exception(e) scope.span.set_tag('couchbase.error', repr(e)) raise + + 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', 'Bucket.n1ql_query', query_with_instana) - logger.debug("Instrumenting couchbase") except ImportError: pass \ No newline at end of file diff --git a/tests/test_couchbase.py b/tests/test_couchbase.py index daed4aac..ba3a6793 100644 --- a/tests/test_couchbase.py +++ b/tests/test_couchbase.py @@ -10,6 +10,7 @@ from couchbase.bucket import Bucket 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) @@ -1207,7 +1208,7 @@ def test_observe_multi(self): self.assertEqual(cb_span.data.couchbase.bucket, 'travel-sample') self.assertEqual(cb_span.data.couchbase.type, 'observe_multi') - def test_n1ql_query(self): + def test_raw_n1ql_query(self): res = None with tracer.start_active_span('test'): @@ -1237,3 +1238,34 @@ def test_n1ql_query(self): 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') + + def test_n1ql_query(self): + res = None + + with tracer.start_active_span('test'): + res = self.bucket.n1ql_query(N1QLQuery('SELECT name FROM `travel-sample` WHERE brewery_id ="mishawaka_brewing"')) + + self.assertIsNotNone(res) + + spans = self.recorder.queued_spans() + self.assertEqual(2, len(spans)) + + test_span = get_first_span_by_name(spans, 'sdk') + self.assertIsNotNone(test_span) + self.assertEqual(test_span.data.sdk.name, 'test') + + cb_span = get_first_span_by_name(spans, 'couchbase') + self.assertIsNotNone(cb_span) + + # Same traceId and parent relationship + self.assertEqual(test_span.t, cb_span.t) + self.assertEqual(cb_span.p, test_span.s) + + self.assertIsNotNone(cb_span.stack) + self.assertFalse(cb_span.error) + 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"') From 6739135ff5a485c5a93d42e1388bf94b3bb646f4 Mon Sep 17 00:00:00 2001 From: Peter Giacomo Lombardo Date: Mon, 2 Dec 2019 22:37:00 +0100 Subject: [PATCH 12/12] Supported versions lockdown --- instana/instrumentation/couchbase_inst.py | 21 ++++++++++++--------- 1 file changed, 12 insertions(+), 9 deletions(-) diff --git a/instana/instrumentation/couchbase_inst.py b/instana/instrumentation/couchbase_inst.py index cc18446e..387147ae 100644 --- a/instana/instrumentation/couchbase_inst.py +++ b/instana/instrumentation/couchbase_inst.py @@ -1,9 +1,10 @@ """ -couchbase instrumentation - This instrumentation supports the Python CouchBase 2.5 SDK only currently: +couchbase instrumentation - This instrumentation supports the Python CouchBase 2.3.4 --> 2.5.x SDK currently: https://docs.couchbase.com/python-sdk/2.5/start-using-sdk.html """ from __future__ import absolute_import +from distutils.version import LooseVersion import wrapt from ..log import logger @@ -11,6 +12,7 @@ try: import couchbase + from couchbase.n1ql import N1QLQuery # List of operations to instrument # incr, incr_multi, decr, decr_multi, retrieve_in are wrappers around operations above @@ -30,7 +32,7 @@ def capture_kvs(scope, instance, query_arg, op): if query_arg is not None: query = None - if type(query_arg) is couchbase.n1ql.N1QLQuery: + if type(query_arg) is N1QLQuery: query = query_arg.statement else: query = query_arg @@ -74,13 +76,14 @@ def query_with_instana(wrapped, instance, args, kwargs): scope.span.set_tag('couchbase.error', repr(e)) raise + if hasattr(couchbase, '__version__') \ + and (LooseVersion(couchbase.__version__) >= LooseVersion('2.3.4')) \ + and (LooseVersion(couchbase.__version__) < LooseVersion('3.0.0')): + logger.debug("Instrumenting couchbase") + 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', 'Bucket.n1ql_query', query_with_instana) - - for op in operations: - f = make_wrapper(op) - wrapt.wrap_function_wrapper('couchbase.bucket', 'Bucket.%s' % op, f) - - logger.debug("Instrumenting couchbase") except ImportError: pass \ No newline at end of file