rasa-pro 3.13.1a18__py3-none-any.whl → 3.13.1a20__py3-none-any.whl

rasa/builder/logging_utils.py

@@ -1,11 +1,20 @@
-"""Logging utilities for the prompt-to-bot service."""
+"""Logging and Sentry utilities for the builder service."""
 
 import collections
 import logging
 import threading
-from typing import Any, Deque, Dict
+import time
+import uuid
+from typing import Any, Deque, Dict, Mapping, MutableMapping, Optional
+
+import sentry_sdk
+import structlog
+from sanic import Request
 
 from rasa.builder import config
+from rasa.builder.auth import HEADER_USER_ID
+
+structlogger = structlog.get_logger()
 
 # Thread-safe deque for collecting recent logs
 _recent_logs: Deque[str] = collections.deque(maxlen=config.MAX_LOG_ENTRIES)
@@ -13,8 +22,8 @@ _logs_lock = threading.RLock()
 
 
 def collecting_logs_processor(
-    logger: Any, log_level: str, event_dict: Dict[str, Any]
-) -> Dict[str, Any]:
+    logger: Any, log_level: str, event_dict: MutableMapping[str, Any]
+) -> MutableMapping[str, Any]:
     """Structlog processor that collects recent log entries.
 
     This processor is thread-safe and maintains a rolling buffer of recent logs.
@@ -29,6 +38,22 @@ def collecting_logs_processor(
     return event_dict
 
 
+def attach_request_id_processor(
+    logger: Any, log_level: str, event_dict: MutableMapping[str, Any]
+) -> MutableMapping[str, Any]:
+    """Structlog processor that attaches the request id to the event dict.
+
+    This processor is thread-safe and maintains a rolling buffer of recent logs.
+    """
+    try:
+        request = Request.get_current()
+        event_dict["correlation_id"] = request.ctx.correlation_id
+        return event_dict
+    except Exception:
+        # there is no request context, so we don't attach the request id
+        return event_dict
+
+
 def get_recent_logs() -> str:
     """Get recent log entries as a formatted string.
 
@@ -49,3 +74,136 @@ def get_log_count() -> int:
     """Get the current number of log entries."""
     with _logs_lock:
         return len(_recent_logs)
+
+
+def _sanitize_headers(headers: Mapping[str, str]) -> Dict[str, Any]:
+    """Remove or redact sensitive headers for safe logging and Sentry context."""
+    lowered = {k.lower(): v for k, v in headers.items()}
+    result: Dict[str, Any] = {}
+    # Safe keepers
+    if "user-agent" in lowered:
+        result["user-agent"] = lowered["user-agent"]
+    if HEADER_USER_ID in lowered:
+        result[HEADER_USER_ID] = lowered[HEADER_USER_ID]
+    # Redact auth info
+    if "authorization" in lowered:
+        auth_val = lowered["authorization"]
+        # Keep only the scheme if present
+        scheme = auth_val.split(" ")[0] if auth_val else ""
+        result["authorization"] = f"{scheme} <redacted>" if scheme else "present"
+    return result
+
+
+def ensure_correlation_id_on_request(request: Any) -> str:
+    """Ensure a correlation id exists on the request and return it."""
+    if not hasattr(request.ctx, "correlation_id") or not request.ctx.correlation_id:
+        request.ctx.correlation_id = uuid.uuid4().hex
+    return request.ctx.correlation_id
+
+
+def extract_request_context() -> Dict[str, Any]:
+    """Extract safe request context for logging / Sentry."""
+    try:
+        request = Request.get_current()
+        headers = getattr(request, "headers", {}) or {}
+        args = getattr(request, "args", {}) or {}
+        json_body = getattr(request, "json", None)
+        content_length = getattr(request, "content_length", None)
+        ctx: Dict[str, Any] = {
+            "method": getattr(request, "method", None),
+            "path": getattr(request, "path", None),
+            "query_args": dict(args) if hasattr(args, "items") else args,
+            "remote_addr": getattr(request, "remote_addr", None),
+            "content_length": content_length,
+            "has_json": json_body is not None,
+            "headers": _sanitize_headers(dict(headers)),
+        }
+        if hasattr(request, "ctx"):
+            ctx["correlation_id"] = ensure_correlation_id_on_request(request)
+            # Common custom fields if present
+            ctx["user_id"] = request.headers.get(HEADER_USER_ID)
+        return ctx
+    except Exception:
+        return {}
+
+
+def capture_exception_with_context(
+    exc: BaseException,
+    event_id: str,
+    extra: Optional[Dict[str, Any]] = None,
+    tags: Optional[Dict[str, str]] = None,
+) -> None:
+    """Capture exception in Sentry and log it with rich context.
+
+    Args:
+        request: Sanic request
+        exc: exception instance
+        event_id: structlog event id
+        extra: additional context to include
+        tags: sentry tags to attach
+    """
+    request_ctx = extract_request_context()
+    if extra is None:
+        extra = {}
+    # Sentry scope
+    try:
+        with sentry_sdk.configure_scope() as scope:
+            scope.set_tag("service", "bot-builder")
+            if tags:
+                for k, v in tags.items():
+                    scope.set_tag(k, v)
+            # Flatten some useful fields as tags
+            if request_ctx.get("path"):
+                scope.set_tag("route", request_ctx["path"])
+            if request_ctx.get("method"):
+                scope.set_tag("method", request_ctx["method"])
+            if request_ctx.get("correlation_id"):
+                scope.set_tag("correlation_id", request_ctx["correlation_id"])
+            user_id = request_ctx.get("user_id")
+            if user_id and hasattr(scope, "set_user"):
+                scope.set_user({"id": str(user_id)})
+            # Context blocks
+            scope.set_context("request", request_ctx)
+            if extra:
+                scope.set_context("extra", extra)
+        sentry_sdk.capture_exception(exc)
+    except Exception:
+        # Never fail the app because Sentry failed
+        pass
+
+    # Structlog error with merged context (avoid dumping huge payloads)
+    structlogger.error(
+        event_id,
+        error=str(exc),
+        **{k: v for k, v in {**request_ctx, **extra}.items() if k not in {"headers"}},
+    )
+
+
+def log_request_start(request: Any) -> float:
+    """Log request start and return start time."""
+    start = time.perf_counter()
+    cid = ensure_correlation_id_on_request(request)
+    ctx = extract_request_context()
+    structlogger.info(
+        "request.received",
+        method=ctx.get("method"),
+        path=ctx.get("path"),
+        remote_addr=ctx.get("remote_addr") or "unknown",
+        correlation_id=cid,
+        user_id=ctx.get("user_id"),
+    )
+    return start
+
+
+def log_request_end(request: Any, response: Any, start: float) -> None:
+    """Log request completion with latency and correlation id."""
+    latency_ms = int((time.perf_counter() - start) * 1000)
+    cid = ensure_correlation_id_on_request(request)
+    structlogger.info(
+        "request.completed",
+        method=getattr(request, "method", None),
+        path=getattr(request, "path", None),
+        status=getattr(response, "status", None),
+        latency_ms=latency_ms,
+        correlation_id=cid,
+    )

rasa/builder/main.py

@@ -11,8 +11,14 @@ from sanic.request import Request
 from sanic_openapi import openapi3_blueprint
 
 import rasa.core.utils
+import rasa.telemetry
 from rasa.builder import config
-from rasa.builder.logging_utils import collecting_logs_processor
+from rasa.builder.logging_utils import (
+    attach_request_id_processor,
+    collecting_logs_processor,
+    log_request_end,
+    log_request_start,
+)
 from rasa.builder.service import bp, setup_project_generator
 from rasa.core.channels.studio_chat import StudioChatInput
 from rasa.server import configure_cors
@@ -37,7 +43,7 @@ def setup_logging() -> None:
     configure_structlog(
         log_level,
         include_time=True,
-        additional_processors=[collecting_logs_processor],
+        additional_processors=[attach_request_id_processor, collecting_logs_processor],
     )
 
 
@@ -52,23 +58,26 @@ def setup_input_channel() -> StudioChatInput:
 def setup_middleware(app: Sanic) -> None:
     """Setup middleware for request/response processing."""
 
-    @app.middleware("request")
+    @app.middleware("request")  # type: ignore[misc,no-untyped-call]
     async def log_request(request: Request) -> None:
-        structlogger.info(
-            "request.received",
-            method=request.method,
-            path=request.path,
-            remote_addr=request.remote_addr or "unknown",
-        )
+        # store start time on request ctx for later latency calculation
+        request.ctx._start_time = log_request_start(request)
 
-    @app.middleware("response")
+    @app.middleware("response")  # type: ignore[misc,no-untyped-call]
     async def log_response(request: Request, response: HTTPResponse) -> None:
-        structlogger.info(
-            "request.completed",
-            method=request.method,
-            path=request.path,
-            status=response.status,
-        )
+        try:
+            start = getattr(request.ctx, "_start_time", None)
+            if start is None:
+                # If for some reason the request middleware didn't run
+                start = log_request_start(request)
+            # propagate correlation id for clients
+            correlation_id = getattr(request.ctx, "correlation_id", None)
+            if correlation_id:
+                response.headers["X-Correlation-Id"] = correlation_id
+            log_request_end(request, response, start)
+        except Exception:
+            # avoid breaking response path
+            pass
 
 
 def create_app(project_folder: Optional[str] = None) -> Sanic:
@@ -116,6 +125,10 @@ def main(project_folder: Optional[str] = None) -> None:
         # Setup logging
         setup_logging()
 
+        # Setup telemetry
+        rasa.telemetry.initialize_telemetry()
+        rasa.telemetry.initialize_error_reporting(private_mode=False)
+
         # Create and configure app
         app = create_app(project_folder)
         register_custom_sanic_error_handler(app)

rasa/builder/models.py

@@ -1,11 +1,15 @@
 """Pydantic models for request/response validation."""
 
-from typing import Any, Dict, List, Literal, Optional, Union
+import json
+from enum import Enum
+from typing import Any, Dict, List, Literal, Optional
 
+import structlog
 from pydantic import BaseModel, Field, validator
 
 from rasa.cli.scaffold import ProjectTemplateName
-from rasa.shared.core.trackers import DialogueStateTracker
+
+structlogger = structlog.get_logger()
 
 
 class PromptRequest(BaseModel):
@@ -14,9 +18,6 @@ class PromptRequest(BaseModel):
     prompt: str = Field(
         ..., min_length=1, max_length=10000, description="The skill description prompt"
     )
-    client_id: Optional[str] = Field(
-        None, max_length=255, description="Optional client identifier"
-    )
 
     @validator("prompt")
     def validate_prompt(cls, v: str) -> str:
@@ -34,9 +35,6 @@ class TemplateRequest(BaseModel):
             f"The template name to use ({ProjectTemplateName.supported_values()})"
         ),
     )
-    client_id: Optional[str] = Field(
-        None, max_length=255, description="Optional client identifier"
-    )
 
     @validator("template_name")
     def validate_template_name(cls, v: Any) -> Any:
@@ -47,33 +45,6 @@ class TemplateRequest(BaseModel):
         return v
 
 
-class ChatMessage(BaseModel):
-    """Model for chat messages."""
-
-    type: str = Field(..., pattern="^(user|assistant)$")
-    content: Union[str, List[Dict[str, Any]]] = Field(...)
-
-
-class LLMBuilderRequest(BaseModel):
-    """Request model for LLM builder endpoint."""
-
-    messages: List[ChatMessage] = Field(..., min_items=1, max_items=50)
-
-
-class LLMBuilderContext(BaseModel):
-    """Context model for LLM builder endpoint."""
-
-    tracker: Optional[DialogueStateTracker] = Field(None)
-    bot_logs: str = Field("")
-    chat_bot_files: Dict[str, str] = Field({})
-    chat_history: List[ChatMessage] = Field([])
-
-    class Config:
-        """Config for LLMBuilderContext."""
-
-        arbitrary_types_allowed = True
-
-
 class BotDataUpdateRequest(BaseModel):
     """Request model for bot data updates."""
 
@@ -87,67 +58,101 @@ class BotDataUpdateRequest(BaseModel):
         allow_population_by_field_name = True
 
 
-class ContentBlock(BaseModel):
-    """Base model for content blocks."""
+class BotData(BaseModel):
+    """Data of a running assistant."""
 
-    type: str = Field(...)
+    domain: Dict[str, Any] = Field(..., description="The domain of the assistant.")
+    flows: Dict[str, Any] = Field(..., description="The flows of the assistant.")
 
 
-class TextBlock(ContentBlock):
-    """Text content block."""
+class AssistantInfo(BaseModel):
+    """Basic information about the loaded assistant."""
 
-    type: Literal["text"] = "text"
-    text: str = Field(...)
+    assistant_id: Optional[str] = Field(
+        None,
+        description=(
+            "Assistant identifier coming from `assistant_id` in the model "
+            "metadata (config.yml)."
+        ),
+    )
 
 
-class CodeBlock(ContentBlock):
-    """Code content block."""
+class ApiErrorResponse(BaseModel):
+    """API error response model."""
 
-    type: Literal["code"] = "code"
-    text: str = Field(...)
-    language: Optional[str] = Field(None)
+    status: Literal["error"] = "error"
+    error: str = Field(...)
+    details: Optional[Dict[str, Any]] = Field(None)
 
 
-class FileBlock(ContentBlock):
-    """File content block."""
+class ServerSentEventType(str, Enum):
+    progress = "progress"
+    error = "error"
+    _EOF = "_EOF"
 
-    type: Literal["file"] = "file"
-    file: str = Field(...)
-    content: str = Field(...)
 
+class ServerSentEvent(BaseModel):
+    """Generic Server-Sent Event payload."""
 
-class LinkBlock(ContentBlock):
-    """Link content block."""
+    event: str = Field(..., description="SSE event name / type")
+    data: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Arbitrary JSON-serializable payload",
+    )
 
-    type: Literal["link"] = "link"
-    text: str = Field(..., pattern=r"^https?://")
+    @classmethod
+    def build(cls, event: str, data: Any) -> "ServerSentEvent":
+        """General-purpose constructor.
 
+        Args:
+            event: The event name (e.g. "progress", "error").
+            data: Arbitrary key-value pairs to include in the payload.
 
-class LLMHelperResponse(BaseModel):
-    """Response model for LLM helper."""
+        Returns:
+            A ServerSentEvent instance with the specified event and data.
+        """
+        return cls(event=event, data=data)
 
-    content_blocks: List[Union[TextBlock, CodeBlock, FileBlock, LinkBlock]] = Field(...)
+    @classmethod
+    def eof(cls) -> "ServerSentEvent":
+        """Helper that returns the special end-of-stream marker."""
+        return cls(event=ServerSentEventType._EOF.value, data={})
 
+    def format(self) -> str:
+        """Return the text representation used by SSE protocols."""
+        return (
+            f"event: {self.event}\n"
+            f"data: {json.dumps(self.data, separators=(', ', ': '))}\n\n"
+        )
 
-class ApiErrorResponse(BaseModel):
-    """API error response model."""
 
-    status: Literal["error"] = "error"
-    error: str = Field(...)
-    details: Optional[Dict[str, Any]] = Field(None)
+class JobStatusEvent(ServerSentEvent):
+    """Job status event with special handling for progress and error states."""
 
+    @classmethod
+    def from_status(
+        cls,
+        status: str,
+        message: Optional[str] = None,
+    ) -> "JobStatusEvent":
+        """Factory for job-status events.
 
-class ServerSentEvent(BaseModel):
-    """Server-sent event model."""
+        Args:
+            status: The job status (e.g. "training", "train_success").
+            message: Optional error message for error events.
 
-    event: str = Field(...)
-    data: Dict[str, Any] = Field(...)
+        Returns:
+            A JobStatusEvent instance with the appropriate event type and data.
+        """
+        event_type = (
+            ServerSentEventType.error if message else ServerSentEventType.progress
+        )
 
-    def format(self) -> str:
-        """Format as SSE string."""
-        import json
+        payload: Dict[str, Any] = {"status": status}
+        if message:
+            payload["message"] = message
 
-        return f"event: {self.event}\ndata: {json.dumps(self.data)}\n\n"
+        return cls(event=event_type.value, data=payload)
 
 
 class ValidationResult(BaseModel):
@@ -169,57 +174,24 @@ class TrainingResult(BaseModel):
 BotFiles = Dict[str, Optional[str]]
 
 
-class Document(BaseModel):
-    """Model for document retrieval results."""
+class JobStatus(str, Enum):
+    received = "received"
+    done = "done"
+    error = "error"
 
-    content: str = Field(...)
-    url: Optional[str] = Field(None)
-    title: Optional[str] = Field(None)
-    metadata: Optional[Dict[str, Any]] = Field(None)
+    generating = "generating"
+    generation_success = "generation_success"
+    generation_error = "generation_error"
 
-    @classmethod
-    def from_inkeep_rag_response(cls, rag_item: Dict[str, Any]) -> "Document":
-        """Create a Document object from a single InKeep RAG response item.
+    training = "training"
+    train_success = "train_success"
+    train_error = "train_error"
 
-        Args:
-            rag_item: Single item from InKeep RAG response
+    validating = "validating"
+    validation_success = "validation_success"
+    validation_error = "validation_error"
 
-        Returns:
-            Document object with extracted content and metadata
-        """
-        source = rag_item.get("source", {})
-        text_content = cls._extract_text_from_source(source)
-
-        return cls(
-            content=text_content.strip() if text_content else "",
-            url=rag_item.get("url"),
-            title=rag_item.get("title"),
-            metadata={
-                "type": rag_item.get("type"),
-                "record_type": rag_item.get("record_type"),
-                "context": rag_item.get("context"),
-                "media_type": source.get("media_type"),
-            },
-        )
-
-    @staticmethod
-    def _extract_text_from_source(source: Dict[str, Any]) -> str:
-        """Extract text content from InKeep source object.
-
-        Args:
-            source: Source object from InKeep RAG response
 
-        Returns:
-            Extracted text content
-        """
-        # Try to extract from content array first
-        if "content" in source:
-            text_parts = []
-            for content_item in source["content"]:
-                if content_item.get("type") == "text" and content_item.get("text"):
-                    text_parts.append(content_item["text"])
-            if text_parts:
-                return "\n".join(text_parts)
-
-        # Fallback to source data
-        return source.get("data", "")
+class JobCreateResponse(BaseModel):
+    job_id: str = Field(...)
+    status: JobStatus = JobStatus.received