haystack-ml-stack 0.2.4__tar.gz → 0.3.0__tar.gz

{haystack_ml_stack-0.2.4 → haystack_ml_stack-0.3.0}/PKG-INFO

@@ -1,18 +1,20 @@
 Metadata-Version: 2.4
 Name: haystack-ml-stack
-Version: 0.2.4
+Version: 0.3.0
 Summary: Functions related to Haystack ML
 Author-email: Oscar Vega <oscar@haystack.tv>
 License: MIT
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: pydantic==2.5.0
-Requires-Dist: cachetools==5.5.2
-Requires-Dist: cloudpickle==2.2.1
-Requires-Dist: aioboto3==12.0.0
-Requires-Dist: fastapi==0.104.1
-Requires-Dist: pydantic-settings==2.2
-Requires-Dist: newrelic==11.1.0
+Requires-Dist: protobuf==6.33.2
+Provides-Extra: server
+Requires-Dist: pydantic==2.5.0; extra == "server"
+Requires-Dist: cachetools==5.5.2; extra == "server"
+Requires-Dist: cloudpickle==2.2.1; extra == "server"
+Requires-Dist: aioboto3==12.0.0; extra == "server"
+Requires-Dist: fastapi==0.104.1; extra == "server"
+Requires-Dist: pydantic-settings==2.2; extra == "server"
+Requires-Dist: newrelic==11.1.0; extra == "server"
 
 # Haystack ML Stack
 

{haystack_ml_stack-0.2.4 → haystack_ml_stack-0.3.0}/pyproject.toml

@@ -5,18 +5,23 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "haystack-ml-stack"
-version = "0.2.4"
+version = "0.3.0"
 description = "Functions related to Haystack ML"
 readme = "README.md"
 authors = [{ name = "Oscar Vega", email = "oscar@haystack.tv" }]
 requires-python = ">=3.11"
 dependencies = [
+    "protobuf==6.33.2",
+]
+license = { text = "MIT" }
+
+[project.optional-dependencies]
+server = [
     "pydantic==2.5.0",
     "cachetools==5.5.2",
     "cloudpickle==2.2.1",
     "aioboto3==12.0.0",
     "fastapi==0.104.1",
     "pydantic-settings==2.2",
-    "newrelic==11.1.0"
-]
-license = { text = "MIT" }
+    "newrelic==11.1.0",
+]

haystack_ml_stack-0.3.0/src/haystack_ml_stack/__init__.py

@@ -0,0 +1,14 @@
+__all__ = []
+
+try:
+    from .app import create_app
+
+    __all__ = ["create_app"]
+except ImportError:
+    pass
+
+from ._serializers import SerializerRegistry, FeatureRegistryId
+
+__all__ = [*__all__, "SerializerRegistry", "FeatureRegistryId"]
+
+__version__ = "0.3.0"

haystack_ml_stack-0.3.0/src/haystack_ml_stack/_serializers.py

@@ -0,0 +1,368 @@
+from .generated.v1 import features_pb2 as features_pb2_v1
+from google.protobuf.message import Message
+from google.protobuf.json_format import ParseDict as ProtoParseDict
+import typing as _t
+from abc import ABC, abstractmethod
+
+MessageType = _t.TypeVar("MessageType", bound=Message)
+
+
+class Serializer(ABC):
+    @abstractmethod
+    def serialize(self, value) -> bytes: ...
+
+    @abstractmethod
+    def deserialize(self, value: bytes) -> _t.Any: ...
+
+
+class SimpleSerializer(Serializer, _t.Generic[MessageType]):
+    """This simple serializer uses the function `ParseDict` provided by google
+    to parse dictionaries. While it allows for simple code, it's very slow to run.
+    This class should be used directly for PoCs only, production serializers should have
+    custom implementations where fields are set directly. Early tests show that
+    manual serialization can provide 10x speedup.
+
+    Deserialization is fine since it deserializes from the binary into the message
+    itself, it doesn't need to create a dictionary."""
+
+    def __init__(self, msg_class: type[MessageType]):
+        self.msg_class = msg_class
+        return
+
+    def serialize(self, value) -> bytes:
+        msg = self.msg_class()
+        return ProtoParseDict(value, message=msg).SerializeToString()
+
+    def deserialize(self, value) -> MessageType:
+        msg: Message = self.msg_class()
+        msg.ParseFromString(value)
+        return msg
+
+
+class StreamPWatchedSerializerV1(SimpleSerializer):
+    def __init__(self):
+        super().__init__(msg_class=features_pb2_v1.StreamPWatched)
+
+    def serialize(self, value):
+        root_msg = self.build_msg(value)
+        return root_msg.SerializeToString()
+
+    def build_msg(self, value) -> features_pb2_v1.StreamPWatched:
+        message = self.msg_class()
+        assert value["version"] == 1, "Wrong version given!"
+        message.version = value["version"]
+        for entry_context, counts in value["data"].items():
+            entry_context_msg: features_pb2_v1.EntryContextCounts = getattr(
+                message.data, entry_context
+            )
+            entry_context_msg.attempts = int(counts["attempts"])
+            entry_context_msg.watched = int(counts["watched"])
+        return message
+
+
+UserPWatchedSerializerV1 = StreamPWatchedSerializerV1
+
+
+class StreamPWatchedSerializerV0(Serializer):
+    serializer_v1 = StreamPWatchedSerializerV1()
+
+    def serialize(self, value) -> bytes:
+        raise NotImplementedError(
+            "This serializer should never be used for serialization!"
+        )
+
+    def deserialize(self, value) -> features_pb2_v1.StreamPWatched:
+        value = {
+            "data": {
+                entry_context.replace(" ", "_"): counts
+                for entry_context, counts in value.items()
+            },
+            "version": 1,
+        }
+        return self.serializer_v1.build_msg(value)
+
+
+class StreamPSelectSerializerV1(SimpleSerializer):
+    def __init__(self):
+        super().__init__(msg_class=features_pb2_v1.StreamPSelect)
+        return
+
+    def serialize(self, value) -> bytes:
+        root_msg = self.build_msg(value)
+        return root_msg.SerializeToString()
+
+    def build_msg(self, value) -> features_pb2_v1.StreamPSelect:
+        message: features_pb2_v1.StreamPSelect = self.msg_class()
+        assert value["version"] == 1, "Wrong version given!"
+        message.version = 1
+        data = value["data"]
+        for (
+            browsed_debias_key,
+            position_pselects,
+        ) in data.items():
+            position_pselects_msg: features_pb2_v1.PositionPSelect = getattr(
+                message.data, browsed_debias_key
+            )
+            for position, select_counts in position_pselects.items():
+                select_counts_msg = getattr(position_pselects_msg, position)
+                select_counts_msg.total_selects = int(select_counts["total_selects"])
+                select_counts_msg.total_browsed = int(select_counts["total_browsed"])
+                select_counts_msg.total_selects_and_watched = int(
+                    select_counts["total_selects_and_watched"]
+                )
+        return message
+
+
+UserPSelectSerializerV1 = StreamPSelectSerializerV1
+
+
+class StreamPSelectSerializerV0(Serializer):
+    serializer_v1 = StreamPSelectSerializerV1()
+
+    def serialize(self, value) -> bytes:
+        raise NotImplementedError(
+            "This serializer should never be used for serialization!"
+        )
+
+    def deserialize(self, value):
+        key_mapping = {
+            "0": "first_pos",
+            "1": "second_pos",
+            "2": "third_pos",
+            "3+": "rest_pos",
+        }
+        for browsed_debiasing in value.keys():
+            for old_key, new_key in key_mapping.items():
+                if old_key not in value[browsed_debiasing]:
+                    continue
+                value[browsed_debiasing][new_key] = value[browsed_debiasing].pop(
+                    old_key
+                )
+        out = {
+            "data": {
+                "up_to_4_browsed": value["4_browsed"],
+                "all_browsed": value["all_browsed"],
+            },
+            "version": 1,
+        }
+        msg = self.serializer_v1.build_msg(value=out)
+        return msg
+
+
+class StreamSimilaritySerializerV1(SimpleSerializer):
+    def __init__(self):
+        super().__init__(msg_class=features_pb2_v1.StreamSimilarityScores)
+
+    def serialize(self, value):
+        msg = self.build_msg(value)
+        return msg.SerializeToString()
+
+    def build_msg(self, value) -> features_pb2_v1.StreamSimilarityScores:
+        message = self.msg_class()
+        assert value["version"] == 1, "Wrong version given!"
+        message.version = value["version"]
+        for key, score in value["data"].items():
+            message.data[key] = score
+        return message
+
+
+class StreamSimilaritySerializerV0(Serializer):
+    serializer_v1 = StreamSimilaritySerializerV1()
+
+    def serialize(self, value):
+        raise NotImplementedError(
+            "This serializer should never be used for serialization!"
+        )
+
+    def deserialize(self, value):
+        value = {"data": value, "version": 1}
+        msg = self.serializer_v1.build_msg(value)
+        return msg
+
+
+class UserPersonalizingPWatchedSerializerV1(SimpleSerializer):
+    def __init__(self):
+        super().__init__(msg_class=features_pb2_v1.UserPersonalizingPWatched)
+
+    def serialize(self, value: dict) -> bytes:
+        root_msg = self.build_msg(value)
+        return root_msg.SerializeToString()
+
+    def build_msg(self, value) -> features_pb2_v1.UserPersonalizingPWatched:
+        root_msg = features_pb2_v1.UserPersonalizingPWatched()
+        assert value["version"] == 1, "Wrong version given!"
+        root_msg.version = value["version"]
+        data = value["data"]
+        for personalizing_key, entry_context_pwatched in data.items():
+            personalizing_msg = root_msg.data[personalizing_key]
+            for entry_context, counts in entry_context_pwatched.items():
+                entry_context_msg = getattr(personalizing_msg, entry_context)
+                entry_context_msg.attempts = int(counts["attempts"])
+                entry_context_msg.watched = int(counts["watched"])
+        return root_msg
+
+
+class UserPersonalizingPSelectSerializerV1(SimpleSerializer):
+    def __init__(self):
+        super().__init__(msg_class=features_pb2_v1.UserPersonalizingPSelect)
+
+    def serialize(self, value):
+        root_msg = features_pb2_v1.UserPersonalizingPSelect()
+        root_msg.version = value["version"]
+        data = value["data"]
+        for personalizing_key, browsed_debiased_pselecs in data.items():
+            personalizing_msg = root_msg.data[personalizing_key]
+            for (
+                browsed_debias_key,
+                position_pselects,
+            ) in browsed_debiased_pselecs.items():
+                position_pselects_msg = getattr(personalizing_msg, browsed_debias_key)
+                for position, select_counts in position_pselects.items():
+                    select_counts_msg = getattr(position_pselects_msg, position)
+                    select_counts_msg.total_selects = int(
+                        select_counts["total_selects"]
+                    )
+                    select_counts_msg.total_browsed = int(
+                        select_counts["total_browsed"]
+                    )
+                    select_counts_msg.total_selects_and_watched = int(
+                        select_counts["total_selects_and_watched"]
+                    )
+        return root_msg.SerializeToString()
+
+
+class PassThroughSerializer(Serializer):
+    def serialize(self, value):
+        return value
+
+    def deserialize(self, value):
+        return value
+
+
+user_personalizing_pwatched_serializer_v1 = UserPersonalizingPWatchedSerializerV1()
+user_pwatched_serializer_v1 = UserPWatchedSerializerV1()
+user_personalizing_pselect_serializer_v1 = UserPersonalizingPSelectSerializerV1()
+user_pselect_serializer_v1 = UserPSelectSerializerV1()
+stream_pwatched_serializer_v0 = StreamPWatchedSerializerV0()
+stream_pwatched_serializer_v1 = StreamPWatchedSerializerV1()
+stream_pselect_serializer_v0 = StreamPSelectSerializerV0()
+stream_pselect_serializer_v1 = StreamPSelectSerializerV1()
+stream_similarity_scores_serializer_v0 = StreamSimilaritySerializerV0()
+stream_similarity_scores_serializer_v1 = StreamSimilaritySerializerV1()
+
+
+class FeatureRegistryId(_t.NamedTuple):
+    entity_type: _t.Literal["STREAM", "USER"]
+    feature_id: str
+    version: str
+
+
+stream_pwatched_v0_features: list[FeatureRegistryId] = [
+    FeatureRegistryId(entity_type="STREAM", feature_id="PWATCHED#24H", version="v0"),
+    FeatureRegistryId(entity_type="STREAM", feature_id="PWATCHED#24H#TV", version="v0"),
+    FeatureRegistryId(
+        entity_type="STREAM", feature_id="PWATCHED#24H#MOBILE", version="v0"
+    ),
+]
+
+stream_pwatched_v1_features: list[FeatureRegistryId] = [
+    FeatureRegistryId(entity_type="STREAM", feature_id="PWATCHED#24H", version="v1"),
+    FeatureRegistryId(entity_type="STREAM", feature_id="PWATCHED#24H#TV", version="v1"),
+    FeatureRegistryId(
+        entity_type="STREAM", feature_id="PWATCHED#24H#MOBILE", version="v1"
+    ),
+]
+
+stream_pselect_v0_features: list[FeatureRegistryId] = [
+    FeatureRegistryId(entity_type="STREAM", feature_id="PSELECT#24H", version="v0"),
+    FeatureRegistryId(
+        entity_type="STREAM", feature_id="PSELECT#24H#MOBILE", version="v0"
+    ),
+    FeatureRegistryId(entity_type="STREAM", feature_id="PSELECT#24H#TV", version="v0"),
+]
+
+stream_pselect_v1_features: list[FeatureRegistryId] = [
+    FeatureRegistryId(entity_type="STREAM", feature_id="PSELECT#24H", version="v1"),
+    FeatureRegistryId(
+        entity_type="STREAM", feature_id="PSELECT#24H#MOBILE", version="v1"
+    ),
+    FeatureRegistryId(entity_type="STREAM", feature_id="PSELECT#24H#TV", version="v1"),
+]
+
+stream_similarity_v0_features: list[FeatureRegistryId] = [
+    FeatureRegistryId(entity_type="STREAM", feature_id="SIMILARITY", version="v0"),
+    FeatureRegistryId(
+        entity_type="STREAM", feature_id="SIMILARITY#WEATHER_ALERT", version="v0"
+    ),
+]
+
+stream_similarity_v1_features: list[FeatureRegistryId] = [
+    FeatureRegistryId(
+        entity_type="STREAM", feature_id="SIMILARITY#GEMINI", version="v1"
+    ),
+    FeatureRegistryId(
+        entity_type="STREAM", feature_id="SIMILARITY#WEATHER_ALERT", version="v1"
+    ),
+]
+
+user_personalizing_pwatched_v1_features: list[FeatureRegistryId] = [
+    FeatureRegistryId(
+        entity_type="USER", feature_id="PWATCHED#6M#CATEGORY", version="v1"
+    ),
+    FeatureRegistryId(
+        entity_type="USER",
+        feature_id="PWATCHED#6M#AUTHOR_SHOW",
+        version="v1",
+    ),
+    FeatureRegistryId(
+        entity_type="USER",
+        feature_id="PWATCHED#6M#GEMINI_CATEGORY",
+        version="v1",
+    ),
+]
+
+user_personalizing_pselect_v1_features: list[FeatureRegistryId] = [
+    FeatureRegistryId(
+        entity_type="USER", feature_id="PSELECT#6M#CATEGORY", version="v1"
+    ),
+    FeatureRegistryId(
+        entity_type="USER", feature_id="PSELECT#6M#AUTHOR_SHOW", version="v1"
+    ),
+    FeatureRegistryId(
+        entity_type="USER", feature_id="PSELECT#6M#GEMINI_CATEGORY", version="v1"
+    ),
+]
+
+user_bias_pwatched_v1_features: list[FeatureRegistryId] = [
+    FeatureRegistryId(entity_type="USER", feature_id="PWATCHED#6M", version="v1")
+]
+
+user_bias_pselect_v1_features: list[FeatureRegistryId] = [
+    FeatureRegistryId(entity_type="USER", feature_id="PSELECT#6M", version="v1")
+]
+
+features_serializer_tuples: list[tuple[list[FeatureRegistryId], Serializer]] = [
+    (stream_pwatched_v0_features, stream_pwatched_serializer_v0),
+    (stream_pwatched_v1_features, stream_pwatched_serializer_v1),
+    (stream_pselect_v0_features, stream_pselect_serializer_v0),
+    (stream_pselect_v1_features, stream_pselect_serializer_v1),
+    (stream_similarity_v0_features, stream_similarity_scores_serializer_v0),
+    (stream_similarity_v1_features, stream_similarity_scores_serializer_v1),
+    (
+        user_personalizing_pwatched_v1_features,
+        user_personalizing_pwatched_serializer_v1,
+    ),
+    (user_bias_pwatched_v1_features, user_pwatched_serializer_v1),
+    (user_personalizing_pselect_v1_features, user_personalizing_pselect_serializer_v1),
+    (user_bias_pselect_v1_features, user_pselect_serializer_v1),
+]
+
+SerializerRegistry: dict[FeatureRegistryId, Serializer] = {
+    FeatureRegistryId(
+        entity_type="PASS_THROUGH", feature_id="PASS_THROUGH", version="v1"
+    ): PassThroughSerializer()
+}
+
+for feature_ids, serializer in features_serializer_tuples:
+    for feature_id in feature_ids:
+        SerializerRegistry[feature_id] = serializer

{haystack_ml_stack-0.2.4 → haystack_ml_stack-0.3.0}/src/haystack_ml_stack/app.py

@@ -5,17 +5,22 @@ import sys
 from http import HTTPStatus
 from typing import Any, Dict, List, Optional
 import time
+from contextlib import asynccontextmanager, AsyncExitStack
 
 import aiobotocore.session
+from aiobotocore.config import AioConfig
 from fastapi import FastAPI, HTTPException, Request, Response
 from fastapi.encoders import jsonable_encoder
 import newrelic.agent
 
 
 from .cache import make_features_cache
-from .dynamo import set_stream_features, FeatureRetrievalMeta
+from .dynamo import set_all_features, FeatureRetrievalMeta
 from .model_store import download_and_load_model
 from .settings import Settings
+from . import exceptions
+from ._serializers import SerializerRegistry
+from google.protobuf import text_format
 
 logging.basicConfig(
     level=logging.INFO,
@@ -25,7 +30,62 @@ logging.basicConfig(
 )
 
 logger = logging.getLogger(__name__)
-APP_NAME = os.environ.get("NEW_RELIC_APP_NAME", None)
+MAX_POOL_CONNECTIONS = int(os.environ.get("MAX_POOL_CONNECTIONS", 50))
+
+
+class StreamLoggerProxy:
+    def __init__(self, stream, feature_ids):
+        self._stream = stream
+        self._feature_ids = feature_ids
+
+    def __repr__(self):
+        parts = []
+        for k, v in self._stream.items():
+            if k in self._feature_ids:
+                # Format only when needed for the log output
+                formatted_v = text_format.MessageToString(v, as_one_line=True)
+                parts.append(f"'{k}': '{formatted_v}'")
+            else:
+                parts.append(f"'{k}': {repr(v)}")
+        return "{" + ", ".join(parts) + "}"
+
+
+async def load_model(state, cfg: Settings) -> None:
+    if not cfg.s3_model_path:
+        logger.critical("S3_MODEL_PATH not set; service will be unhealthy.")
+    else:
+        try:
+            # Pass the persistent session/client if needed
+            state["model"] = await download_and_load_model(
+                cfg.s3_model_path, aio_session=state["session"]
+            )
+            state["stream_features"] = state["model"].get("stream_features", [])
+            state["user_features"] = state["model"].get("user_features", [])
+            valid_features = set(
+                (entity_type, feature_id)
+                for entity_type, feature_id, _ in SerializerRegistry.keys()
+            )
+            all_features = set(
+                [("STREAM", feature_name) for feature_name in state["stream_features"]]
+                + [("USER", feature_name) for feature_name in state["user_features"]]
+            )
+            invalid_features = all_features.difference(valid_features)
+            if invalid_features:
+                raise exceptions.InvalidFeaturesException(
+                    f"Received invalid features: {invalid_features}"
+                )
+            newrelic.agent.add_custom_attribute(
+                "total_stream_features", len(state["stream_features"])
+            )
+            newrelic.agent.add_custom_attribute(
+                "total_user_features", len(state["user_features"])
+            )
+            logger.info("Model loaded successfully.")
+        except exceptions.InvalidFeaturesException as e:
+            logger.error("%s", e)
+            raise e
+        except Exception as e:
+            logger.critical("Failed to load model: %s", e)
 
 
 def create_app(
@@ -39,40 +99,51 @@ def create_app(
     """
     cfg = settings or Settings()
 
-    app = FastAPI(
-        title="ML Stream Scorer",
-        description="Scores video streams using a pre-trained ML model and DynamoDB features.",
-        version="1.0.0",
-    )
-
     # Mutable state: cache + model
-    features_cache = make_features_cache(cfg.cache_maxsize)
+    stream_features_cache = make_features_cache(cfg.stream_cache_maxsize)
+    user_features_cache = make_features_cache(cfg.user_cache_maxsize)
+    aws_session = aiobotocore.session.get_session()
     state: Dict[str, Any] = {
         "model": preloaded_model,
-        "session": aiobotocore.session.get_session(),
+        "session": aws_session,
         "model_name": (
             os.path.basename(cfg.s3_model_path) if cfg.s3_model_path else None
         ),
     }
 
-    @app.on_event("startup")
-    async def _startup() -> None:
-        if state["model"] is not None:
-            logger.info("Using preloaded model.")
-            return
+    @asynccontextmanager
+    async def lifespan(app_server: FastAPI):
+        """
+        Handles startup and shutdown logic.
+        Everything before 'yield' runs on startup.
+        Everything after 'yield' runs on shutdown.
+        """
+        # 1. Load ML Model
+        if state["model"] is None:
+            await load_model(state, cfg)
+        async with AsyncExitStack() as stack:
+            # 2. Initialize DynamoDB Client (Persistent Pool)
+            session = state["session"]
+            state["dynamo_client"] = await stack.enter_async_context(
+                session.create_client(
+                    "dynamodb",
+                    # Ensure the pool is large enough for ML concurrency
+                    config=AioConfig(max_pool_connections=MAX_POOL_CONNECTIONS),
+                )
+            )
+            logger.info("DynamoDB persistent client initialized.")
+            yield
 
-        if not cfg.s3_model_path:
-            logger.critical("S3_MODEL_PATH not set; service will be unhealthy.")
-            return
+            # 3. Shutdown Logic
+            # The AsyncExitStack automatically closes the DynamoDB client pool here
+            logger.info("Shutting down: Connection pools closed.")
 
-        try:
-            state["model"] = await download_and_load_model(
-                cfg.s3_model_path, aio_session=state["session"]
-            )
-            state["stream_features"] = state["model"].get("stream_features", [])
-            logger.info("Model loaded on startup.")
-        except Exception as e:
-            logger.critical("Failed to load model: %s", e)
+    app = FastAPI(
+        title="ML Stream Scorer",
+        description="Scores video streams using a pre-trained ML model and DynamoDB features.",
+        version="1.0.0",
+        lifespan=lifespan,
+    )
 
     @app.get("/health", status_code=HTTPStatus.OK)
     async def health():
@@ -85,7 +156,8 @@ def create_app(
         return {
             "status": "ok",
             "model_loaded": True,
-            "cache_size": len(features_cache),
+            "stream_cache_size": len(stream_features_cache),
+            "user_cache_size": len(user_features_cache),
             "model_name": state.get("model_name"),
             "stream_features": state.get("stream_features", []),
         }
@@ -120,8 +192,11 @@ def create_app(
         # Feature fetch (optional based on model)
         model = state["model"]
         stream_features = model.get("stream_features", []) or []
+        user_features = model.get("user_features", []) or []
         retrieval_meta = FeatureRetrievalMeta(
             cache_misses=0,
+            stream_cache_misses=0,
+            user_cache_misses=0,
             retrieval_ms=0,
             success=True,
             cache_delay_minutes=0,
@@ -129,21 +204,40 @@ def create_app(
             parsing_ms=0,
         )
         if stream_features:
-            retrieval_meta = await set_stream_features(
-                aio_session=state["session"],
-                streams=streams,
-                stream_features=stream_features,
-                features_cache=features_cache,
-                features_table=cfg.features_table,
-                stream_pk_prefix=cfg.stream_pk_prefix,
-                cache_sep=cfg.cache_separator,
-            )
+            try:
+                retrieval_meta = await set_all_features(
+                    dynamo_client=state["dynamo_client"],
+                    user=user,
+                    streams=streams,
+                    stream_features=stream_features,
+                    user_features=user_features,
+                    stream_features_cache=stream_features_cache,
+                    user_features_cache=user_features_cache,
+                    features_table=cfg.features_table,
+                    cache_sep=cfg.cache_separator,
+                )
+            except exceptions.InvalidFeaturesException as e:
+                logger.error(
+                    "The following features are not present in the SerializerRegistry %s",
+                    e,
+                )
+                raise HTTPException(
+                    status_code=HTTPStatus.SERVICE_UNAVAILABLE,
+                    detail=f"Received invalid features from feature store: {e}",
+                ) from e
 
         random_number = random.random()
         userid = user.get("userid", "")
         # Sampling logs
         if random_number < cfg.logs_fraction:
-            logger.info("User %s streams: %s", user.get("userid", ""), streams)
+            logger.info(
+                "User %s streams: %s",
+                user.get("userid", ""),
+                [
+                    StreamLoggerProxy(s, stream_features + user_features)
+                    for s in streams
+                ],
+            )
 
         # Synchronous model execution (user code)
         try:
@@ -168,8 +262,9 @@ def create_app(
         newrelic.agent.record_custom_event(
             "Inference",
             {
-                "app_name": APP_NAME,
                 "cache_misses": retrieval_meta.cache_misses,
+                "user_cache_misses": retrieval_meta.user_cache_misses,
+                "stream_cache_misses": retrieval_meta.stream_cache_misses,
                 "retrieval_success": int(retrieval_meta.success),
                 "cache_delay_minutes": retrieval_meta.cache_delay_minutes,
                 "dynamo_ms": retrieval_meta.dynamo_ms,