PYCBC-1767: Use nullcontext when using no-op observability

Changes
-------
* Add `create()` static method to `ObservableRequestHandler` that will
  return the observability context manager if observability is enabled,
  otherwise returns `nullcontext()`.  The changes allows the `if
  instruments.is_noop:` branch in KV operations to be cleaned up to a
  single context manager call.
* Add `_NOOP_OBS_HANDLER_CTX` module-level singleton to use instead of
  needing to create a `nullcontext()` on every no-op path call.

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

Author: thejcfactor

acouchbase/binary_collection.py

@@ -83,10 +83,7 @@ async def increment(self,
 
         """
         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:
+        async with ObservableRequestHandler.create(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)
 
@@ -136,10 +133,7 @@ async def decrement(self,
 
         """
         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:
+        async with ObservableRequestHandler.create(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)
 
@@ -197,10 +191,7 @@ async def append(self,
 
         """
         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:
+        async with ObservableRequestHandler.create(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)
 
@@ -258,9 +249,6 @@ async def prepend(self,
 
         """
         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:
+        async with ObservableRequestHandler.create(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

@@ -120,10 +120,7 @@ async def get(self,
 
         """
         instruments = self._impl.observability_instruments
-        if instruments.is_noop:
-            req, transcoder = self._impl.request_builder.build_get_request(key, None, *opts, **kwargs)
-            return await self._impl.get(req, transcoder, None)
-        async with ObservableRequestHandler(KeyValueOperationType.Get, instruments) as obs_handler:
+        async with ObservableRequestHandler.create(KeyValueOperationType.Get, instruments) as obs_handler:
             req, transcoder = self._impl.request_builder.build_get_request(key, obs_handler, *opts, **kwargs)
             return await self._impl.get(req, transcoder, obs_handler)
 
@@ -174,10 +171,7 @@ async def get_any_replica(self,
 
         """  # noqa: E501
         instruments = self._impl.observability_instruments
-        if instruments.is_noop:
-            req, transcoder = self._impl.request_builder.build_get_any_replica_request(key, None, *opts, **kwargs)
-            return await self._impl.get_any_replica(req, transcoder, None)
-        async with ObservableRequestHandler(KeyValueOperationType.GetAnyReplica, instruments) as obs_handler:
+        async with ObservableRequestHandler.create(KeyValueOperationType.GetAnyReplica, instruments) as obs_handler:
             req, transcoder = self._impl.request_builder.build_get_any_replica_request(
                 key, obs_handler, *opts, **kwargs)
             return await self._impl.get_any_replica(req, transcoder, obs_handler)
@@ -249,10 +243,7 @@ async def get_all_replicas(self,
 
         """
         instruments = self._impl.observability_instruments
-        if instruments.is_noop:
-            req, transcoder = self._impl.request_builder.build_get_all_replicas_request(key, None, *opts, **kwargs)
-            return await self._impl.get_all_replicas(req, transcoder, None)
-        async with ObservableRequestHandler(KeyValueOperationType.GetAllReplicas, instruments) as obs_handler:
+        async with ObservableRequestHandler.create(KeyValueOperationType.GetAllReplicas, instruments) as obs_handler:
             req, transcoder = self._impl.request_builder.build_get_all_replicas_request(
                 key, obs_handler, *opts, **kwargs)
             return await self._impl.get_all_replicas(req, transcoder, obs_handler)
@@ -299,10 +290,7 @@ async def exists(self,
 
         """
         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:
+        async with ObservableRequestHandler.create(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)
 
@@ -369,10 +357,7 @@ async def insert(self,
 
         """
         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:
+        async with ObservableRequestHandler.create(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)
 
@@ -435,10 +420,7 @@ async def upsert(self,
 
         """
         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:
+        async with ObservableRequestHandler.create(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)
 
@@ -495,10 +477,7 @@ async def replace(self,
 
         """
         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:
+        async with ObservableRequestHandler.create(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)
 
@@ -545,10 +524,7 @@ async def remove(self,
 
         """
         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:
+        async with ObservableRequestHandler.create(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)
 
@@ -603,10 +579,7 @@ async def touch(self,
 
         """
         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:
+        async with ObservableRequestHandler.create(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)
 
@@ -664,10 +637,7 @@ async def get_and_touch(self,
 
         """
         instruments = self._impl.observability_instruments
-        if instruments.is_noop:
-            req, transcoder = self._impl.request_builder.build_get_and_touch_request(key, expiry, None, *opts, **kwargs)
-            return await self._impl.get_and_touch(req, transcoder, None)
-        async with ObservableRequestHandler(KeyValueOperationType.GetAndTouch, instruments) as obs_handler:
+        async with ObservableRequestHandler.create(KeyValueOperationType.GetAndTouch, instruments) as obs_handler:
             req, transcoder = self._impl.request_builder.build_get_and_touch_request(
                 key, expiry, obs_handler, *opts, **kwargs)
             return await self._impl.get_and_touch(req, transcoder, obs_handler)
@@ -726,11 +696,7 @@ async def get_and_lock(self,
 
         """
         instruments = self._impl.observability_instruments
-        if instruments.is_noop:
-            req, transcoder = self._impl.request_builder.build_get_and_lock_request(
-                key, lock_time, None, *opts, **kwargs)
-            return await self._impl.get_and_lock(req, transcoder, None)
-        async with ObservableRequestHandler(KeyValueOperationType.GetAndLock, instruments) as obs_handler:
+        async with ObservableRequestHandler.create(KeyValueOperationType.GetAndLock, instruments) as obs_handler:
             req, transcoder = self._impl.request_builder.build_get_and_lock_request(
                 key, lock_time, obs_handler, *opts, **kwargs)
             return await self._impl.get_and_lock(req, transcoder, obs_handler)
@@ -778,10 +744,7 @@ async def unlock(self,
 
         """
         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:
+        async with ObservableRequestHandler.create(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)
 
@@ -843,10 +806,7 @@ async def lookup_in(self,
 
         """
         instruments = self._impl.observability_instruments
-        if instruments.is_noop:
-            req, transcoder = self._impl.request_builder.build_lookup_in_request(key, spec, None, *opts, **kwargs)
-            return await self._impl.lookup_in(req, transcoder, None)
-        async with ObservableRequestHandler(KeyValueOperationType.LookupIn, instruments) as obs_handler:
+        async with ObservableRequestHandler.create(KeyValueOperationType.LookupIn, instruments) as obs_handler:
             req, transcoder = self._impl.request_builder.build_lookup_in_request(
                 key, spec, obs_handler, *opts, **kwargs)
             return await self._impl.lookup_in(req, transcoder, obs_handler)
@@ -911,11 +871,9 @@ async def lookup_in_any_replica(self,
 
         """
         instruments = self._impl.observability_instruments
-        if instruments.is_noop:
-            req, transcoder = self._impl.request_builder.build_lookup_in_any_replica_request(
-                key, spec, None, *opts, **kwargs)
-            return await self._impl.lookup_in_any_replica(req, transcoder, None)
-        async with ObservableRequestHandler(KeyValueOperationType.LookupInAnyReplica, instruments) as obs_handler:
+        async with ObservableRequestHandler.create(
+            KeyValueOperationType.LookupInAnyReplica, instruments
+        ) as obs_handler:
             req, transcoder = 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, transcoder, obs_handler)
@@ -1003,11 +961,9 @@ async def lookup_in_all_replicas(self,
 
         """  # noqa: E501
         instruments = self._impl.observability_instruments
-        if instruments.is_noop:
-            req, transcoder = self._impl.request_builder.build_lookup_in_all_replicas_request(
-                key, spec, None, *opts, **kwargs)
-            return await self._impl.lookup_in_all_replicas(req, transcoder, None)
-        async with ObservableRequestHandler(KeyValueOperationType.LookupInAllReplicas, instruments) as obs_handler:
+        async with ObservableRequestHandler.create(
+            KeyValueOperationType.LookupInAllReplicas, instruments
+        ) as obs_handler:
             req, transcoder = 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, transcoder, obs_handler)
@@ -1068,10 +1024,7 @@ async def mutate_in(self,
 
         """
         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:
+        async with ObservableRequestHandler.create(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)