reflex 0.5.0a3__py3-none-any.whl → 0.5.1__py3-none-any.whl

reflex/utils/processes.py

@@ -211,6 +211,7 @@ def stream_logs(
     process: subprocess.Popen,
     progress=None,
     suppress_errors: bool = False,
+    analytics_enabled: bool = False,
 ):
     """Stream the logs for a process.
 
@@ -219,6 +220,7 @@ def stream_logs(
         process: The process.
         progress: The ongoing progress bar if one is being used.
         suppress_errors: If True, do not exit if errors are encountered (for fallback).
+        analytics_enabled: Whether analytics are enabled for this command.
 
     Yields:
         The lines of the process output.
@@ -226,6 +228,8 @@ def stream_logs(
     Raises:
         Exit: If the process failed.
     """
+    from reflex.utils import telemetry
+
     # Store the tail of the logs.
     logs = collections.deque(maxlen=512)
     with process:
@@ -246,6 +250,8 @@ def stream_logs(
         console.error(f"{message} failed with exit code {process.returncode}")
         for line in logs:
             console.error(line, end="")
+        if analytics_enabled:
+            telemetry.send("error", context=message)
         console.error("Run with [bold]--loglevel debug [/bold] for the full log.")
         raise typer.Exit(1)
 
@@ -261,16 +267,27 @@ def show_logs(message: str, process: subprocess.Popen):
         pass
 
 
-def show_status(message: str, process: subprocess.Popen, suppress_errors: bool = False):
+def show_status(
+    message: str,
+    process: subprocess.Popen,
+    suppress_errors: bool = False,
+    analytics_enabled: bool = False,
+):
     """Show the status of a process.
 
     Args:
         message: The initial message to display.
         process: The process.
         suppress_errors: If True, do not exit if errors are encountered (for fallback).
+        analytics_enabled: Whether analytics are enabled for this command.
     """
     with console.status(message) as status:
-        for line in stream_logs(message, process, suppress_errors=suppress_errors):
+        for line in stream_logs(
+            message,
+            process,
+            suppress_errors=suppress_errors,
+            analytics_enabled=analytics_enabled,
+        ):
             status.update(f"{message} {line}")
 
 
@@ -319,19 +336,31 @@ def get_command_with_loglevel(command: list[str]) -> list[str]:
     return command
 
 
-def run_process_with_fallback(args, *, show_status_message, fallback=None, **kwargs):
+def run_process_with_fallback(
+    args,
+    *,
+    show_status_message,
+    fallback=None,
+    analytics_enabled: bool = False,
+    **kwargs,
+):
     """Run subprocess and retry using fallback command if initial command fails.
 
     Args:
         args: A string, or a sequence of program arguments.
         show_status_message: The status message to be displayed in the console.
         fallback: The fallback command to run.
+        analytics_enabled: Whether analytics are enabled for this command.
         kwargs: Kwargs to pass to new_process function.
     """
     process = new_process(get_command_with_loglevel(args), **kwargs)
     if fallback is None:
         # No fallback given, or this _is_ the fallback command.
-        show_status(show_status_message, process)
+        show_status(
+            show_status_message,
+            process,
+            analytics_enabled=analytics_enabled,
+        )
     else:
         # Suppress errors for initial command, because we will try to fallback
         show_status(show_status_message, process, suppress_errors=True)
@@ -345,6 +374,7 @@ def run_process_with_fallback(args, *, show_status_message, fallback=None, **kwa
                 fallback_args,
                 show_status_message=show_status_message,
                 fallback=None,
+                analytics_enabled=analytics_enabled,
                 **kwargs,
             )
 

reflex/utils/telemetry.py

@@ -2,8 +2,10 @@
 
 from __future__ import annotations
 
+import asyncio
 import multiprocessing
 import platform
+import warnings
 
 try:
     from datetime import UTC, datetime
@@ -126,6 +128,10 @@ def _prepare_event(event: str, **kwargs) -> dict:
 
     cpuinfo = get_cpu_info()
 
+    additional_keys = ["template", "context", "detail"]
+    additional_fields = {
+        key: value for key in additional_keys if (value := kwargs.get(key)) is not None
+    }
     return {
         "api_key": "phc_JoMo0fOyi0GQAooY3UyO9k0hebGkMyFJrrCw1Gt5SGb",
         "event": event,
@@ -139,11 +145,7 @@ def _prepare_event(event: str, **kwargs) -> dict:
             "cpu_count": get_cpu_count(),
             "memory": get_memory(),
             "cpu_info": dict(cpuinfo) if cpuinfo else {},
-            **(
-                {"template": template}
-                if (template := kwargs.get("template")) is not None
-                else {}
-            ),
+            **additional_fields,
         },
         "timestamp": stamp,
     }
@@ -157,17 +159,7 @@ def _send_event(event_data: dict) -> bool:
         return False
 
 
-def send(event: str, telemetry_enabled: bool | None = None, **kwargs) -> bool:
-    """Send anonymous telemetry for Reflex.
-
-    Args:
-        event: The event name.
-        telemetry_enabled: Whether to send the telemetry (If None, get from config).
-        kwargs: Additional data to send with the event.
-
-    Returns:
-        Whether the telemetry was sent successfully.
-    """
+def _send(event, telemetry_enabled, **kwargs):
     from reflex.config import get_config
 
     # Get the telemetry_enabled from the config if it is not specified.
@@ -182,3 +174,37 @@ def send(event: str, telemetry_enabled: bool | None = None, **kwargs) -> bool:
     if not event_data:
         return False
     return _send_event(event_data)
+
+
+def send(event: str, telemetry_enabled: bool | None = None, **kwargs):
+    """Send anonymous telemetry for Reflex.
+
+    Args:
+        event: The event name.
+        telemetry_enabled: Whether to send the telemetry (If None, get from config).
+        kwargs: Additional data to send with the event.
+    """
+
+    async def async_send(event, telemetry_enabled, **kwargs):
+        return _send(event, telemetry_enabled, **kwargs)
+
+    try:
+        # Within an event loop context, send the event asynchronously.
+        asyncio.create_task(async_send(event, telemetry_enabled, **kwargs))
+    except RuntimeError:
+        # If there is no event loop, send the event synchronously.
+        warnings.filterwarnings("ignore", category=RuntimeWarning)
+        _send(event, telemetry_enabled, **kwargs)
+
+
+def send_error(error: Exception, context: str):
+    """Send an error event.
+
+    Args:
+        error: The error to send.
+        context: The context of the error (e.g. "frontend" or "backend")
+
+    Returns:
+        Whether the telemetry was sent successfully.
+    """
+    return send("error", detail=type(error).__name__, context=context)

reflex/utils/types.py

@@ -44,6 +44,22 @@ from reflex import constants
 from reflex.base import Base
 from reflex.utils import console, serializers
 
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+
+    def override(func: Callable) -> Callable:
+        """Fallback for @override decorator.
+
+        Args:
+            func: The function to decorate.
+
+        Returns:
+            The unmodified function.
+        """
+        return func
+
+
 # Potential GenericAlias types for isinstance checks.
 GenericAliasTypes = [_GenericAlias]