kinto 23.0.2__py3-none-any.whl → 23.1.0__py3-none-any.whl

kinto/core/cache/__init__.py

@@ -10,10 +10,15 @@ _HEARTBEAT_KEY = "__heartbeat__"
 _HEARTBEAT_TTL_SECONDS = 3600
 
 
+_CACHE_HIT_METRIC_KEY = "cache_hits"
+_CACHE_MISS_METRIC_KEY = "cache_misses"
+
+
 class CacheBase:
     def __init__(self, *args, **kwargs):
         self.prefix = kwargs["cache_prefix"]
         self.max_size_bytes = kwargs.get("cache_max_size_bytes")
+        self.set_metrics_backend(kwargs.get("metrics_backend"))
 
     def initialize_schema(self, dry_run=False):
         """Create every necessary objects (like tables or indices) in the
@@ -71,6 +76,36 @@ class CacheBase:
         """
         raise NotImplementedError
 
+    def set_metrics_backend(self, metrics_backend):
+        """Set a metrics backend via the `CacheMetricsBackend` adapter.
+
+        :param metrics_backend: A metrics backend implementing the IMetricsService interface.
+        """
+        self.metrics_backend = CacheMetricsBackend(metrics_backend)
+
+
+class CacheMetricsBackend:
+    """
+    A simple adapter for tracking cache-related metrics.
+    """
+
+    def __init__(self, metrics_backend, *args, **kwargs):
+        """Initialize with a given metrics backend.
+
+        :param metrics_backend: A metrics backend implementing the IMetricsService interface.
+        """
+        self._backend = metrics_backend
+
+    def count_hit(self):
+        """Increment the cache hit counter."""
+        if self._backend:
+            self._backend.count(key=_CACHE_HIT_METRIC_KEY)
+
+    def count_miss(self):
+        """Increment the cache miss counter."""
+        if self._backend:
+            self._backend.count(key=_CACHE_MISS_METRIC_KEY)
+
 
 def heartbeat(backend):
     def ping(request):

kinto/core/cache/memcached.py

@@ -68,7 +68,9 @@ class Cache(CacheBase):
     def _get(self, key):
         value = self._client.get(self.prefix + key)
         if not value:
+            self.metrics_backend.count_miss()
             return None, 0
+        self.metrics_backend.count_hit()
         data = json.loads(value)
         return data["value"], data["ttl"]
 

kinto/core/cache/memory.py

@@ -73,7 +73,12 @@ class Cache(CacheBase):
     @synchronized
     def get(self, key):
         self._clean_expired()
-        return self._store.get(self.prefix + key)
+        value = self._store.get(self.prefix + key)
+        if value is None:
+            self.metrics_backend.count_miss()
+            return None
+        self.metrics_backend.count_hit()
+        return value
 
     @synchronized
     def delete(self, key):

kinto/core/cache/postgresql/__init__.py

@@ -156,8 +156,11 @@ class Cache(CacheBase):
             conn.execute(sa.text(purge))
             result = conn.execute(sa.text(query), dict(key=self.prefix + key))
             if result.rowcount > 0:
+                self.metrics_backend.count_hit()
                 value = result.fetchone().value
                 return json.loads(value)
+            self.metrics_backend.count_miss()
+            return None
 
     def delete(self, key):
         query = "DELETE FROM cache WHERE key = :key RETURNING value;"

kinto/core/initialization.py

@@ -228,7 +228,9 @@ def _end_of_life_tween_factory(handler, registry):
         else:
             code = "hard-eol"
             request.response = errors.http_error(
-                HTTPGone(), errno=errors.ERRORS.SERVICE_DEPRECATED, message=deprecation_msg
+                HTTPGone(),
+                errno=errors.ERRORS.SERVICE_DEPRECATED,
+                message=deprecation_msg,
             )
 
         errors.send_alert(request, eos_message, url=eos_url, code=code)
@@ -459,6 +461,11 @@ def setup_metrics(config):
         else:
             metrics.watch_execution_time(metrics_service, policy, prefix="authentication")
 
+        # Set cache metrics backend
+        cache_backend = config.registry.cache
+        if isinstance(cache_backend, cache.CacheBase):
+            cache_backend.set_metrics_backend(metrics_service)
+
     config.add_subscriber(on_app_created, ApplicationCreated)
 
     def on_new_response(event):
@@ -468,8 +475,9 @@ def setup_metrics(config):
         # Count unique users.
         user_id = request.prefixed_userid
         if user_id:
-            # Get rid of colons in metric packet (see #1282).
-            auth, user_id = user_id.split(":")
+            auth, user_id = user_id.split(":", 1)
+            # Get rid of colons in metric packet (see #1282 and  #3571).
+            user_id = user_id.replace(":", ".")
             metrics_service.count("users", unique=[("auth", auth), ("userid", user_id)])
 
         status = event.response.status_code

kinto/core/resource/__init__.py

@@ -319,7 +319,7 @@ class Resource:
     #
 
     def plural_head(self):
-        """Model ``HEAD`` endpoint: empty reponse with a ``Total-Objects`` header.
+        """Model ``HEAD`` endpoint: empty response with a ``Total-Objects`` header.
 
         :raises: :exc:`~pyramid:pyramid.httpexceptions.HTTPNotModified` if
             ``If-None-Match`` header is provided and collection not
@@ -1135,6 +1135,14 @@ class Resource:
             if field == self.model.modified_field and not is_valid_timestamp(value):
                 raise_invalid(self.request, **error_details)
 
+            if field in (self.model.modified_field, self.model.id_field) and operator in (
+                COMPARISON.CONTAINS,
+                COMPARISON.CONTAINS_ANY,
+            ):
+                error_msg = f"Field '{field}' is not an array"
+                error_details["description"] = error_msg
+                raise_invalid(self.request, **error_details)
+
             filters.append(Filter(field, value, operator))
 
         # If a plural endpoint is reached, and if the user does not have the

kinto/core/resource/schema.py

@@ -21,7 +21,7 @@ positive_big_integer = colander.Range(min=0, max=POSTGRESQL_MAX_INTEGER_VALUE)
 
 
 class TimeStamp(TimeStamp):
-    """This schema is deprecated, you shoud use `kinto.core.schema.TimeStamp` instead."""
+    """This schema is deprecated, you should use `kinto.core.schema.TimeStamp` instead."""
 
     def __init__(self, *args, **kwargs):
         message = (
@@ -33,7 +33,7 @@ class TimeStamp(TimeStamp):
 
 
 class URL(URL):
-    """This schema is deprecated, you shoud use `kinto.core.schema.URL` instead."""
+    """This schema is deprecated, you should use `kinto.core.schema.URL` instead."""
 
     def __init__(self, *args, **kwargs):
         message = (
@@ -422,7 +422,7 @@ class PluralResponseSchema(colander.MappingSchema):
         return datalist
 
 
-class ResourceReponses:
+class ResourceResponses:
     """Class that wraps and handles Resource responses."""
 
     default_schemas = {
@@ -448,7 +448,7 @@ class ResourceReponses:
     }
     default_get_schemas = {
         "304": NotModifiedResponseSchema(
-            description="Reponse has not changed since value in If-None-Match header"
+            description="Response has not changed since value in If-None-Match header"
         )
     }
     default_post_schemas = {

kinto/core/resource/viewset.py

@@ -16,7 +16,7 @@ from .schema import (
     PluralGetQuerySchema,
     PluralQuerySchema,
     RequestSchema,
-    ResourceReponses,
+    ResourceResponses,
 )
 
 
@@ -64,7 +64,7 @@ class ViewSet:
 
     factory = authorization.RouteFactory
 
-    responses = ResourceReponses()
+    responses = ResourceResponses()
 
     service_arguments = {"description": "Set of {resource_name}"}
 

kinto/core/storage/postgresql/__init__.py

@@ -884,6 +884,14 @@ class Storage(StorageBase, MigratorMixin):
                 operator = "IS NOT NULL" if filtr.value else "IS NULL"
                 cond = f"{sql_field} {operator}"
 
+            elif filtr.operator == COMPARISON.CONTAINS:
+                value_holder = f"{prefix}_value_{i}"
+                holders[value_holder] = value
+                # In case the field is not a sequence, we ignore the object.
+                is_json_sequence = f"jsonb_typeof({sql_field}) = 'array'"
+                sql_operator = operators[filtr.operator]
+                cond = f"{is_json_sequence} AND {sql_field} {sql_operator} :{value_holder}"
+
             elif filtr.operator == COMPARISON.CONTAINS_ANY:
                 value_holder = f"{prefix}_value_{i}"
                 holders[value_holder] = value

kinto/core/storage/testing.py

@@ -491,6 +491,14 @@ class BaseTestStorage:
         objects = self.storage.list_all(filters=filters, **self.storage_kw)
         self.assertEqual(len(objects), 0)
 
+    def test_list_all_contains_ignores_object_if_field_is_not_array(self):
+        self.create_object({"code": "black"})
+        self.create_object({"fib": ["a", "b", "c"]})
+
+        filters = [Filter("fib", ["a"], utils.COMPARISON.CONTAINS)]
+        objects = self.storage.list_all(filters=filters, **self.storage_kw)
+        self.assertEqual(len(objects), 1)
+
     def test_list_all_can_filter_on_array_with_contains_any_and_unsupported_type(self):
         self.create_object({"code": "black"})
         self.create_object({"fib": [2, 3, 5]})

kinto/core/utils.py

@@ -422,7 +422,7 @@ def follow_subrequest(request, subrequest, **kwargs):
     """Run a subrequest (e.g. batch), and follow the redirection if any.
 
     :rtype: tuple
-    :returns: the reponse and the redirection request (or `subrequest`
+    :returns: the response and the redirection request (or `subrequest`
               if no redirection happened.)
     """
     try:

kinto/plugins/admin/VERSION

@@ -1 +1 @@
-3.7.1
+4.3.0

kinto/plugins/admin/build/VERSION

@@ -1 +1 @@
-3.7.1
+4.3.0