PYCBC-1762: Observability Code Structure Improvements

Changes
-------
* For no-op tracing AND metrics, allow collection logic to skip
  ObservabilityHandler
* Update *Request dataclasses to use cached properties when using
  req_to_dict() method

Change-Id: Ia388e36ceda38c64095d203ff584ba4e809c7488
Reviewed-on: https://review.couchbase.org/c/couchbase-python-client/+/243592
Tested-by: Build Bot <build@couchbase.com>
Reviewed-by: Dimitris Christodoulou <dimitris.christodoulou@couchbase.com>

Author: thejcfactor

acouchbase/binary_collection.py

@@ -82,8 +82,11 @@ async def increment(self,
                 print(f'Counter value: {res.content}')
 
         """
-        op_type = KeyValueOperationType.Increment
-        async with ObservableRequestHandler(op_type, self._impl.observability_instruments) as obs_handler:
+        instruments = self._impl.observability_instruments
+        if instruments.is_noop:
+            req = self._impl.request_builder.build_increment_request(key, None, *opts, **kwargs)
+            return await self._impl.increment(req, None)
+        async with ObservableRequestHandler(KeyValueOperationType.Increment, instruments) as obs_handler:
             req = self._impl.request_builder.build_increment_request(key, obs_handler, *opts, **kwargs)
             return await self._impl.increment(req, obs_handler)
 
@@ -132,8 +135,11 @@ async def decrement(self,
                 print(f'Counter value: {res.content}')
 
         """
-        op_type = KeyValueOperationType.Decrement
-        async with ObservableRequestHandler(op_type, self._impl.observability_instruments) as obs_handler:
+        instruments = self._impl.observability_instruments
+        if instruments.is_noop:
+            req = self._impl.request_builder.build_decrement_request(key, None, *opts, **kwargs)
+            return await self._impl.decrement(req, None)
+        async with ObservableRequestHandler(KeyValueOperationType.Decrement, instruments) as obs_handler:
             req = self._impl.request_builder.build_decrement_request(key, obs_handler, *opts, **kwargs)
             return await self._impl.decrement(req, obs_handler)
 
@@ -190,8 +196,11 @@ async def append(self,
                                                         AppendOptions(timeout=timedelta(seconds=2)))
 
         """
-        op_type = KeyValueOperationType.Append
-        async with ObservableRequestHandler(op_type, self._impl.observability_instruments) as obs_handler:
+        instruments = self._impl.observability_instruments
+        if instruments.is_noop:
+            req = self._impl.request_builder.build_append_request(key, value, None, *opts, **kwargs)
+            return await self._impl.append(req, None)
+        async with ObservableRequestHandler(KeyValueOperationType.Append, instruments) as obs_handler:
             req = self._impl.request_builder.build_append_request(key, value, obs_handler, *opts, **kwargs)
             return await self._impl.append(req, obs_handler)
 
@@ -248,7 +257,10 @@ async def prepend(self,
                                                         PrependOptions(timeout=timedelta(seconds=2)))
 
         """
-        op_type = KeyValueOperationType.Prepend
-        async with ObservableRequestHandler(op_type, self._impl.observability_instruments) as obs_handler:
+        instruments = self._impl.observability_instruments
+        if instruments.is_noop:
+            req = self._impl.request_builder.build_prepend_request(key, value, None, *opts, **kwargs)
+            return await self._impl.prepend(req, None)
+        async with ObservableRequestHandler(KeyValueOperationType.Prepend, instruments) as obs_handler:
             req = self._impl.request_builder.build_prepend_request(key, value, obs_handler, *opts, **kwargs)
             return await self._impl.prepend(req, obs_handler)

acouchbase/collection.py

@@ -119,8 +119,11 @@ async def get(self,
                 print(f'Document value: {res.content_as[dict]}')
 
         """
-        op_type = KeyValueOperationType.Get
-        async with ObservableRequestHandler(op_type, self._impl.observability_instruments) as obs_handler:
+        instruments = self._impl.observability_instruments
+        if instruments.is_noop:
+            req = self._impl.request_builder.build_get_request(key, None, *opts, **kwargs)
+            return await self._impl.get(req, None)
+        async with ObservableRequestHandler(KeyValueOperationType.Get, instruments) as obs_handler:
             req = self._impl.request_builder.build_get_request(key, obs_handler, *opts, **kwargs)
             return await self._impl.get(req, obs_handler)
 
@@ -170,8 +173,11 @@ async def get_any_replica(self,
                 print(f'Document value: {res.content_as[dict]}')
 
         """  # noqa: E501
-        op_type = KeyValueOperationType.GetAnyReplica
-        async with ObservableRequestHandler(op_type, self._impl.observability_instruments) as obs_handler:
+        instruments = self._impl.observability_instruments
+        if instruments.is_noop:
+            req = self._impl.request_builder.build_get_any_replica_request(key, None, *opts, **kwargs)
+            return await self._impl.get_any_replica(req, None)
+        async with ObservableRequestHandler(KeyValueOperationType.GetAnyReplica, instruments) as obs_handler:
             req = self._impl.request_builder.build_get_any_replica_request(key, obs_handler, *opts, **kwargs)
             return await self._impl.get_any_replica(req, obs_handler)
 
@@ -241,8 +247,11 @@ async def get_all_replicas(self,
                         break
 
         """
-        op_type = KeyValueOperationType.GetAllReplicas
-        async with ObservableRequestHandler(op_type, self._impl.observability_instruments) as obs_handler:
+        instruments = self._impl.observability_instruments
+        if instruments.is_noop:
+            req = self._impl.request_builder.build_get_all_replicas_request(key, None, *opts, **kwargs)
+            return await self._impl.get_all_replicas(req, None)
+        async with ObservableRequestHandler(KeyValueOperationType.GetAllReplicas, instruments) as obs_handler:
             req = self._impl.request_builder.build_get_all_replicas_request(key, obs_handler, *opts, **kwargs)
             return await self._impl.get_all_replicas(req, obs_handler)
 
@@ -287,8 +296,11 @@ async def exists(self,
                 print(f'Document w/ key - {key} {"exists" if res.exists else "does not exist"}')
 
         """
-        op_type = KeyValueOperationType.Exists
-        async with ObservableRequestHandler(op_type, self._impl.observability_instruments) as obs_handler:
+        instruments = self._impl.observability_instruments
+        if instruments.is_noop:
+            req = self._impl.request_builder.build_exists_request(key, None, *opts, **kwargs)
+            return await self._impl.exists(req, None)
+        async with ObservableRequestHandler(KeyValueOperationType.Exists, instruments) as obs_handler:
             req = self._impl.request_builder.build_exists_request(key, obs_handler, *opts, **kwargs)
             return await self._impl.exists(req, obs_handler)
 
@@ -354,8 +366,11 @@ async def insert(self,
                 res = await collection.insert(key, doc, InsertOptions(durability=durability))
 
         """
-        op_type = KeyValueOperationType.Insert
-        async with ObservableRequestHandler(op_type, self._impl.observability_instruments) as obs_handler:
+        instruments = self._impl.observability_instruments
+        if instruments.is_noop:
+            req = self._impl.request_builder.build_insert_request(key, value, None, *opts, **kwargs)
+            return await self._impl.insert(req, None)
+        async with ObservableRequestHandler(KeyValueOperationType.Insert, instruments) as obs_handler:
             req = self._impl.request_builder.build_insert_request(key, value, obs_handler, *opts, **kwargs)
             return await self._impl.insert(req, obs_handler)
 
@@ -417,8 +432,11 @@ async def upsert(self,
                 res = await collection.upsert(key, doc, InsertOptions(durability=durability))
 
         """
-        op_type = KeyValueOperationType.Upsert
-        async with ObservableRequestHandler(op_type, self._impl.observability_instruments) as obs_handler:
+        instruments = self._impl.observability_instruments
+        if instruments.is_noop:
+            req = self._impl.request_builder.build_upsert_request(key, value, None, *opts, **kwargs)
+            return await self._impl.upsert(req, None)
+        async with ObservableRequestHandler(KeyValueOperationType.Upsert, instruments) as obs_handler:
             req = self._impl.request_builder.build_upsert_request(key, value, obs_handler, *opts, **kwargs)
             return await self._impl.upsert(req, obs_handler)
 
@@ -474,8 +492,11 @@ async def replace(self,
                 res = await collection.replace(key, doc, InsertOptions(durability=durability))
 
         """
-        op_type = KeyValueOperationType.Replace
-        async with ObservableRequestHandler(op_type, self._impl.observability_instruments) as obs_handler:
+        instruments = self._impl.observability_instruments
+        if instruments.is_noop:
+            req = self._impl.request_builder.build_replace_request(key, value, None, *opts, **kwargs)
+            return await self._impl.replace(req, None)
+        async with ObservableRequestHandler(KeyValueOperationType.Replace, instruments) as obs_handler:
             req = self._impl.request_builder.build_replace_request(key, value, obs_handler, *opts, **kwargs)
             return await self._impl.replace(req, obs_handler)
 
@@ -521,8 +542,11 @@ async def remove(self,
                 res = collection.remove('airline_10', RemoveOptions(durability=durability))
 
         """
-        op_type = KeyValueOperationType.Remove
-        async with ObservableRequestHandler(op_type, self._impl.observability_instruments) as obs_handler:
+        instruments = self._impl.observability_instruments
+        if instruments.is_noop:
+            req = self._impl.request_builder.build_remove_request(key, None, *opts, **kwargs)
+            return await self._impl.remove(req, None)
+        async with ObservableRequestHandler(KeyValueOperationType.Remove, instruments) as obs_handler:
             req = self._impl.request_builder.build_remove_request(key, obs_handler, *opts, **kwargs)
             return await self._impl.remove(req, obs_handler)
 
@@ -576,8 +600,11 @@ async def touch(self,
                                         TouchOptions(timeout=timedelta(seconds=2)))
 
         """
-        op_type = KeyValueOperationType.Touch
-        async with ObservableRequestHandler(op_type, self._impl.observability_instruments) as obs_handler:
+        instruments = self._impl.observability_instruments
+        if instruments.is_noop:
+            req = self._impl.request_builder.build_touch_request(key, expiry, None, *opts, **kwargs)
+            return await self._impl.touch(req, None)
+        async with ObservableRequestHandler(KeyValueOperationType.Touch, instruments) as obs_handler:
             req = self._impl.request_builder.build_touch_request(key, expiry, obs_handler, *opts, **kwargs)
             return await self._impl.touch(req, obs_handler)
 
@@ -634,8 +661,11 @@ async def get_and_touch(self,
                 print(f'Document w/ updated expiry: {res.content_as[dict]}')
 
         """
-        op_type = KeyValueOperationType.GetAndTouch
-        async with ObservableRequestHandler(op_type, self._impl.observability_instruments) as obs_handler:
+        instruments = self._impl.observability_instruments
+        if instruments.is_noop:
+            req = self._impl.request_builder.build_get_and_touch_request(key, expiry, None, *opts, **kwargs)
+            return await self._impl.get_and_touch(req, None)
+        async with ObservableRequestHandler(KeyValueOperationType.GetAndTouch, instruments) as obs_handler:
             req = self._impl.request_builder.build_get_and_touch_request(key, expiry, obs_handler, *opts, **kwargs)
             return await self._impl.get_and_touch(req, obs_handler)
 
@@ -692,8 +722,11 @@ async def get_and_lock(self,
                 print(f'Locked document: {res.content_as[dict]}')
 
         """
-        op_type = KeyValueOperationType.GetAndLock
-        async with ObservableRequestHandler(op_type, self._impl.observability_instruments) as obs_handler:
+        instruments = self._impl.observability_instruments
+        if instruments.is_noop:
+            req = self._impl.request_builder.build_get_and_lock_request(key, lock_time, None, *opts, **kwargs)
+            return await self._impl.get_and_lock(req, None)
+        async with ObservableRequestHandler(KeyValueOperationType.GetAndLock, instruments) as obs_handler:
             req = self._impl.request_builder.build_get_and_lock_request(key, lock_time, obs_handler, *opts, **kwargs)
             return await self._impl.get_and_lock(req, obs_handler)
 
@@ -739,8 +772,11 @@ async def unlock(self,
                 await collection.upsert(key, res.content_as[dict])
 
         """
-        op_type = KeyValueOperationType.Unlock
-        async with ObservableRequestHandler(op_type, self._impl.observability_instruments) as obs_handler:
+        instruments = self._impl.observability_instruments
+        if instruments.is_noop:
+            req = self._impl.request_builder.build_unlock_request(key, cas, None, *opts, **kwargs)
+            return await self._impl.unlock(req, None)
+        async with ObservableRequestHandler(KeyValueOperationType.Unlock, instruments) as obs_handler:
             req = self._impl.request_builder.build_unlock_request(key, cas, obs_handler, *opts, **kwargs)
             await self._impl.unlock(req, obs_handler)
 
@@ -801,8 +837,11 @@ async def lookup_in(self,
                 print(f'Hotel {key} coordinates: {res.content_as[dict](0)}')
 
         """
-        op_type = KeyValueOperationType.LookupIn
-        async with ObservableRequestHandler(op_type, self._impl.observability_instruments) as obs_handler:
+        instruments = self._impl.observability_instruments
+        if instruments.is_noop:
+            req = self._impl.request_builder.build_lookup_in_request(key, spec, None, *opts, **kwargs)
+            return await self._impl.lookup_in(req, None)
+        async with ObservableRequestHandler(KeyValueOperationType.LookupIn, instruments) as obs_handler:
             req = self._impl.request_builder.build_lookup_in_request(key, spec, obs_handler, *opts, **kwargs)
             return await self._impl.lookup_in(req, obs_handler)
 
@@ -865,8 +904,12 @@ async def lookup_in_any_replica(self,
                 print(f'Hotel {key} coordinates: {res.content_as[dict](0)}')
 
         """
-        op_type = KeyValueOperationType.LookupInAnyReplica
-        async with ObservableRequestHandler(op_type, self._impl.observability_instruments) as obs_handler:
+        instruments = self._impl.observability_instruments
+        if instruments.is_noop:
+            req = self._impl.request_builder.build_lookup_in_any_replica_request(
+                key, spec, None, *opts, **kwargs)
+            return await self._impl.lookup_in_any_replica(req, None)
+        async with ObservableRequestHandler(KeyValueOperationType.LookupInAnyReplica, instruments) as obs_handler:
             req = self._impl.request_builder.build_lookup_in_any_replica_request(
                 key, spec, obs_handler, *opts, **kwargs)
             return await self._impl.lookup_in_any_replica(req, obs_handler)
@@ -953,8 +996,12 @@ async def lookup_in_all_replicas(self,
                         break
 
         """  # noqa: E501
-        op_type = KeyValueOperationType.LookupInAllReplicas
-        async with ObservableRequestHandler(op_type, self._impl.observability_instruments) as obs_handler:
+        instruments = self._impl.observability_instruments
+        if instruments.is_noop:
+            req = self._impl.request_builder.build_lookup_in_all_replicas_request(
+                key, spec, None, *opts, **kwargs)
+            return await self._impl.lookup_in_all_replicas(req, None)
+        async with ObservableRequestHandler(KeyValueOperationType.LookupInAllReplicas, instruments) as obs_handler:
             req = self._impl.request_builder.build_lookup_in_all_replicas_request(
                 key, spec, obs_handler, *opts, **kwargs)
             return await self._impl.lookup_in_all_replicas(req, obs_handler)
@@ -1014,8 +1061,11 @@ async def mutate_in(self,
                                             MutateInOptions(timeout=timedelta(seconds=2)))
 
         """
-        op_type = KeyValueOperationType.MutateIn
-        async with ObservableRequestHandler(op_type, self._impl.observability_instruments) as obs_handler:
+        instruments = self._impl.observability_instruments
+        if instruments.is_noop:
+            req = self._impl.request_builder.build_mutate_in_request(key, spec, None, *opts, **kwargs)
+            return await self._impl.mutate_in(req, None)
+        async with ObservableRequestHandler(KeyValueOperationType.MutateIn, instruments) as obs_handler:
             req = self._impl.request_builder.build_mutate_in_request(key, spec, obs_handler, *opts, **kwargs)
             return await self._impl.mutate_in(req, obs_handler)