plato-sdk-v2 2.1.14__py3-none-any.whl → 2.1.16__py3-none-any.whl

plato/worlds/base.py

@@ -4,11 +4,8 @@ from __future__ import annotations
 
 import logging
 from abc import ABC, abstractmethod
-from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Any, ClassVar, Generic, TypeVar, get_args, get_origin
-from uuid import uuid4
 
-import httpx
 from pydantic import BaseModel, Field
 
 from plato.worlds.config import RunConfig
@@ -16,6 +13,11 @@ from plato.worlds.config import RunConfig
 if TYPE_CHECKING:
     from plato.v2.async_.session import Session
 
+from plato.agents.logging import init_logging as _init_chronos_logging
+from plato.agents.logging import log_event as _log_event
+from plato.agents.logging import reset_logging as _reset_chronos_logging
+from plato.agents.logging import span as _span
+
 logger = logging.getLogger(__name__)
 
 # Global registry of worlds
@@ -104,7 +106,6 @@ class BaseWorld(ABC, Generic[ConfigT]):
         self._step_count: int = 0
         self.plato_session = None
         self._current_step_id: str | None = None
-        self._session_span_id: str | None = None
 
     @classmethod
     def get_config_class(cls) -> type[RunConfig]:
@@ -171,6 +172,9 @@ class BaseWorld(ABC, Generic[ConfigT]):
         This is called automatically during run() to restore the session
         and start sending heartbeats while the world runs.
         """
+        if not self.config.plato_session:
+            return
+
         try:
             from plato.v2.async_.session import Session
 
@@ -189,111 +193,6 @@ class BaseWorld(ABC, Generic[ConfigT]):
             except Exception as e:
                 self.logger.warning(f"Error stopping Plato heartbeat: {e}")
 
-    async def _log_event(
-        self,
-        span_type: str,
-        content: str = "",
-        source: str = "world",
-        log_type: str | None = None,
-        event_id: str | None = None,
-        parent_id: str | None = None,
-        step_number: int | None = None,
-        extra: dict[str, Any] | None = None,
-        started_at: datetime | None = None,
-        ended_at: datetime | None = None,
-    ) -> str | None:
-        """Log an event to the callback API.
-
-        Args:
-            span_type: Type of event (reset, step, trajectory, agent_action, etc.)
-            content: Event description
-            source: Event source (world, agent, system)
-            log_type: Log type for rendering (atif, step, etc.)
-            event_id: Unique ID for this event (generated if not provided)
-            parent_id: Parent event ID for nesting
-            step_number: Step number for ordering
-            extra: Additional structured data
-            started_at: When the event started
-            ended_at: When the event ended
-
-        Returns:
-            The event ID if successfully logged, None otherwise
-        """
-        if not self.config.callback_url or not self.config.session_id:
-            return None
-
-        event_id = event_id or str(uuid4())
-
-        try:
-            async with httpx.AsyncClient(timeout=10.0) as client:
-                response = await client.post(
-                    f"{self.config.callback_url}/event",
-                    json={
-                        "session_id": self.config.session_id,
-                        "event_id": event_id,
-                        "parent_id": parent_id,
-                        "source": source,
-                        "span_type": span_type,
-                        "log_type": log_type,
-                        "step_number": step_number,
-                        "content": content,
-                        "extra": extra,
-                        "started_at": started_at.isoformat() if started_at else None,
-                        "ended_at": ended_at.isoformat() if ended_at else None,
-                    },
-                )
-                if response.status_code == 200:
-                    return event_id
-                else:
-                    self.logger.warning(f"Failed to log event: {response.status_code} {response.text}")
-        except Exception as e:
-            self.logger.warning(f"Failed to log event: {e}")
-
-        return None
-
-    async def log_agent_action(
-        self,
-        agent_name: str,
-        action: str,
-        content: str,
-        extra: dict[str, Any] | None = None,
-    ) -> str | None:
-        """Log an agent action during a step.
-
-        Args:
-            agent_name: Name of the agent
-            action: Action type (e.g., tool_call, response)
-            content: Action content/description
-            extra: Additional data (tool input, output, etc.)
-
-        Returns:
-            The event ID if successfully logged
-        """
-        return await self._log_event(
-            span_type="agent_action",
-            content=f"[{agent_name}] {action}: {content}",
-            source="agent",
-            parent_id=self._current_step_id,
-            step_number=self._step_count,
-            extra={"agent": agent_name, "action": action, **(extra or {})},
-        )
-
-    async def log_trajectory(self, trajectory: dict[str, Any]) -> str | None:
-        """Log an ATIF trajectory.
-
-        Args:
-            trajectory: ATIF trajectory dict
-
-        Returns:
-            The event ID if successfully logged
-        """
-        return await self._log_event(
-            span_type="trajectory",
-            log_type="atif",
-            source="agent",
-            extra=trajectory,
-        )
-
     async def run(self, config: ConfigT) -> None:
         """Run the world: reset -> step until done -> close.
 
@@ -305,84 +204,55 @@ class BaseWorld(ABC, Generic[ConfigT]):
 
         self.logger.info(f"Starting world '{self.name}'")
 
+        # Initialize the logging singleton for agents to use
+        if config.callback_url and config.session_id:
+            _init_chronos_logging(
+                callback_url=config.callback_url,
+                session_id=config.session_id,
+            )
+
         # Connect to Plato session if configured (for heartbeats)
         await self._connect_plato_session()
 
         # Log session start
-        session_start = datetime.now(timezone.utc)
-        self._session_span_id = await self._log_event(
+        await _log_event(
             span_type="session_start",
             content=f"World '{self.name}' started",
             source="world",
-            started_at=session_start,
             extra={"world_name": self.name, "world_version": self.get_version()},
         )
 
         try:
-            # Log and execute reset
-            reset_start = datetime.now(timezone.utc)
-            reset_id = str(uuid4())
-            await self._log_event(
-                span_type="reset",
-                content="World reset started",
-                source="world",
-                event_id=reset_id,
-                parent_id=self._session_span_id,
-                started_at=reset_start,
-            )
-
-            obs = await self.reset()
-            reset_end = datetime.now(timezone.utc)
-
-            await self._log_event(
-                span_type="reset",
-                content="World reset complete",
-                source="world",
-                event_id=reset_id,
-                parent_id=self._session_span_id,
-                started_at=reset_start,
-                ended_at=reset_end,
-                extra={"observation": obs.model_dump() if hasattr(obs, "model_dump") else str(obs)},
-            )
+            # Execute reset with automatic span tracking
+            async with _span("reset", span_type="reset", source="world") as reset_span:
+                reset_span.log(f"Resetting world '{self.name}'")
+                obs = await self.reset()
+                reset_span.set_extra({"observation": obs.model_dump() if hasattr(obs, "model_dump") else str(obs)})
             self.logger.info(f"World reset complete: {obs}")
 
             while True:
                 self._step_count += 1
-                step_start = datetime.now(timezone.utc)
-                self._current_step_id = str(uuid4())
 
-                # Log step start
-                await self._log_event(
+                # Execute step with automatic span tracking
+                # The span automatically sets itself as the current parent,
+                # so agent trajectories will nest under this step
+                async with _span(
+                    f"step_{self._step_count}",
                     span_type="step",
-                    content=f"Step {self._step_count} started",
                     source="world",
-                    event_id=self._current_step_id,
-                    parent_id=self._session_span_id,
-                    step_number=self._step_count,
-                    started_at=step_start,
-                )
-
-                result = await self.step()
-                step_end = datetime.now(timezone.utc)
-
-                # Log step completion
-                await self._log_event(
-                    span_type="step",
-                    content=f"Step {self._step_count} {'completed' if result.done else 'continues'}",
-                    source="world",
-                    event_id=self._current_step_id,
-                    parent_id=self._session_span_id,
-                    step_number=self._step_count,
-                    started_at=step_start,
-                    ended_at=step_end,
-                    extra={
-                        "done": result.done,
-                        "observation": result.observation.model_dump()
-                        if hasattr(result.observation, "model_dump")
-                        else str(result.observation),
-                        "info": result.info,
-                    },
-                )
+                ) as step_span:
+                    self._current_step_id = step_span.event_id
+                    step_span.log(f"Step {self._step_count} started")
+                    result = await self.step()
+                    step_span.set_extra(
+                        {
+                            "done": result.done,
+                            "observation": result.observation.model_dump()
+                            if hasattr(result.observation, "model_dump")
+                            else str(result.observation),
+                            "info": result.info,
+                        }
+                    )
 
                 self.logger.info(f"Step {self._step_count}: done={result.done}")
 
@@ -394,15 +264,14 @@ class BaseWorld(ABC, Generic[ConfigT]):
             await self._disconnect_plato_session()
 
             # Log session end
-            session_end = datetime.now(timezone.utc)
-            await self._log_event(
+            await _log_event(
                 span_type="session_end",
                 content=f"World '{self.name}' completed after {self._step_count} steps",
                 source="world",
-                parent_id=self._session_span_id,
-                started_at=session_start,
-                ended_at=session_end,
                 extra={"total_steps": self._step_count},
             )
 
+            # Reset the logging singleton
+            _reset_chronos_logging()
+
             self.logger.info(f"World '{self.name}' completed after {self._step_count} steps")

plato/worlds/config.py

@@ -74,7 +74,7 @@ class RunConfig(BaseModel):
 
     # Serialized Plato session for connecting to VM and sending heartbeats
     # This is the output of Session.dump() - used to restore session with Session.load()
-    plato_session: SerializedSession
+    plato_session: SerializedSession | None = None
 
     model_config = {"extra": "allow"}
 

{plato_sdk_v2-2.1.14.dist-info → plato_sdk_v2-2.1.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plato-sdk-v2
-Version: 2.1.14
+Version: 2.1.16
 Summary: Python SDK for the Plato API
 Author-email: Plato <support@plato.so>
 License-Expression: MIT

{plato_sdk_v2-2.1.14.dist-info → plato_sdk_v2-2.1.16.dist-info}/RECORD

@@ -294,12 +294,12 @@ plato/_sims_generator/templates/python/errors.py.jinja,sha256=8L_FbHczBNLXJrbSlN
 plato/_sims_generator/templates/python/package_init.py.jinja,sha256=sOcJxUT0LuOWu5jOMGGKYxfCEjcYQv1hGF3n0iOA4hQ,986
 plato/_sims_generator/templates/python/tag_init.py.jinja,sha256=WB_9cv0JKIVg5TOXeSolET3tAfVg7sExjboh5jbCXz4,170
 plato/_sims_generator/templates/python/version_init.py.jinja,sha256=sGvFcYVfzXFyQDAe0PSOrg9yys93KE0XInFQNb1TvCY,179
-plato/agents/__init__.py,sha256=byhtkrMNBDT8lUtryZK_Ov6u-gtnRvyex2OUGKVAy30,2656
+plato/agents/__init__.py,sha256=qslIFTVSe1yFeTRCKr8Z-mInWarj2HDbNZV4u6AiXek,2755
 plato/agents/base.py,sha256=vUbPQuNSo6Ka2lIB_ZOXgi4EoAjtAD7GIj9LnNotam0,4577
 plato/agents/build.py,sha256=CNMbVQFs2_pYit1dA29Davve28Yi4c7TNK9wBB7odrE,1621
-plato/agents/callback.py,sha256=3BdQfAx_nVDRimx9FiuhpaDFiLnvMNB0thCKeszz3D8,11188
 plato/agents/config.py,sha256=VZVMdCmEQnoR0VkrGdScG8p6zSKVFe7BZPd2h8lKNjI,5460
-plato/agents/runner.py,sha256=jgDV28qK1dT1z5IvO61ALpxdULFRvZAIiCWn62_ANfs,11669
+plato/agents/logging.py,sha256=z9rDlGPbrpcTS8PephbK2rDqT7thC1KyLkua4ypUkv4,12210
+plato/agents/runner.py,sha256=rOWYTSAhdola_FdrbviP955NBusNtBUy-q_c5fDA9to,5123
 plato/agents/trajectory.py,sha256=ayXEMCfYvIuXU2JkQWfPOVO9JywNSx8Kf6Ztrgsdh-I,10441
 plato/chronos/__init__.py,sha256=RHMvSrQS_-vkKOyTRuAkp2gKDP1HEuBLDnw8jcZs1Jg,739
 plato/chronos/client.py,sha256=YcOGtHWERyOD9z8LKt8bRMVL0cEwL2hiAP4qQgdZlUI,5495
@@ -459,11 +459,11 @@ plato/v2/utils/models.py,sha256=PwehSSnIRG-tM3tWL1PzZEH77ZHhIAZ9R0UPs6YknbM,1441
 plato/v2/utils/proxy_tunnel.py,sha256=8ZTd0jCGSfIHMvSv1fgEyacuISWnGPHLPbDglWroTzY,10463
 plato/worlds/README.md,sha256=TgG4aidude0ouJSCfY81Ev45hsUxPkO85HUIiWNqkcc,5463
 plato/worlds/__init__.py,sha256=0ogDVw5GEk4OT7FSD0Z7SrafTn_TBdo8DOU_v6ncbd4,1478
-plato/worlds/base.py,sha256=TT7tNNEW-JVV78IFhS3gY1_2afaFvBarK81FGFlRauM,14210
+plato/worlds/base.py,sha256=vLAHkYpYg4kl7LgftQ0uC6xXhASVqREogn6msNWA6Hk,9650
 plato/worlds/build_hook.py,sha256=KSoW0kqa5b7NyZ7MYOw2qsZ_2FkWuz0M3Ru7AKOP7Qw,3486
-plato/worlds/config.py,sha256=RDBGhZRFJNshFVO-1H8xDcqxzUqahlSJtoo-eQpavgs,6242
+plato/worlds/config.py,sha256=-K1dnlRL5I-DNYEoc1I4cKIsTw53X_1QrRY2SWJvRiQ,6256
 plato/worlds/runner.py,sha256=r9B2BxBae8_dM7y5cJf9xhThp_I1Qvf_tlPq2rs8qC8,4013
-plato_sdk_v2-2.1.14.dist-info/METADATA,sha256=aizMxFdqXeYqJQdIzUTnXRVwyPYXax641bLFAIwkVt0,8509
-plato_sdk_v2-2.1.14.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-plato_sdk_v2-2.1.14.dist-info/entry_points.txt,sha256=upGMbJCx6YWUTKrPoYvYUYfFCqYr75nHDwhA-45m6p8,136
-plato_sdk_v2-2.1.14.dist-info/RECORD,,
+plato_sdk_v2-2.1.16.dist-info/METADATA,sha256=5S_mx4Iij8UNv8od9y6b3n8T00t6gFzM01-1wS-rLdg,8509
+plato_sdk_v2-2.1.16.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+plato_sdk_v2-2.1.16.dist-info/entry_points.txt,sha256=upGMbJCx6YWUTKrPoYvYUYfFCqYr75nHDwhA-45m6p8,136
+plato_sdk_v2-2.1.16.dist-info/RECORD,,

plato/agents/callback.py

@@ -1,332 +0,0 @@
-"""Chronos callback utilities for agents.
-
-Simple API:
-- log_event() - Log any event (trajectory, logs, status changes)
-- upload_logs() - Upload logs to S3
-"""
-
-from __future__ import annotations
-
-import base64
-import io
-import json
-import logging
-import zipfile
-from pathlib import Path
-from typing import Any
-
-import httpx
-
-logger = logging.getLogger(__name__)
-
-
-class ChronosCallback:
-    """Utility class for communicating with Chronos server.
-
-    Example:
-        callback = ChronosCallback(
-            callback_url="http://chronos.example.com/api/callback",
-            session_id="abc123",
-        )
-
-        # Log a trajectory event
-        await callback.log_event(
-            span_type="trajectory",
-            log_type="atif",
-            extra=trajectory_dict,
-        )
-
-        # Upload logs to S3
-        await callback.upload_logs(logs_dir="/path/to/logs")
-    """
-
-    def __init__(self, callback_url: str, session_id: str):
-        """Initialize the callback client.
-
-        Args:
-            callback_url: Full callback base URL (e.g., http://server/api/callback)
-            session_id: The Chronos session ID for this run
-        """
-        self.callback_url = callback_url.rstrip("/")
-        self.session_id = session_id
-        self._enabled = bool(callback_url and session_id)
-
-    @property
-    def enabled(self) -> bool:
-        """Check if callbacks are enabled (both server and session_id set)."""
-        return self._enabled
-
-    async def log_event(
-        self,
-        span_type: str,
-        content: str = "",
-        source: str = "agent",
-        log_type: str | None = None,
-        step_number: int | None = None,
-        extra: dict[str, Any] | None = None,
-        event_id: str | None = None,
-        parent_id: str | None = None,
-        started_at: str | None = None,
-        ended_at: str | None = None,
-    ) -> bool:
-        """Log an event to Chronos.
-
-        Use this for all event types:
-        - Trajectory: span_type='trajectory', log_type='atif', extra={...atif data...}
-        - Steps: span_type='step', extra={observation, done, info}
-        - Status: span_type='status_change', extra={status: '...'}
-
-        Args:
-            span_type: Event type (trajectory, step, reset, agent_action, etc.)
-            content: Event description
-            source: Event source (agent, world, system)
-            log_type: Log type for rendering (atif, step, etc.)
-            step_number: Step number for ordering
-            extra: Structured data (trajectory, step info, etc.)
-            event_id: Unique event ID (generated if not provided)
-            parent_id: Parent event ID for nesting
-            started_at: ISO timestamp when event started
-            ended_at: ISO timestamp when event ended
-
-        Returns:
-            True if event was logged successfully, False otherwise.
-        """
-        if not self._enabled:
-            return False
-
-        try:
-            async with httpx.AsyncClient(timeout=30.0) as client:
-                response = await client.post(
-                    f"{self.callback_url}/event",
-                    json={
-                        "session_id": self.session_id,
-                        "span_type": span_type,
-                        "content": content,
-                        "source": source,
-                        "log_type": log_type,
-                        "step_number": step_number,
-                        "extra": extra,
-                        "event_id": event_id,
-                        "parent_id": parent_id,
-                        "started_at": started_at,
-                        "ended_at": ended_at,
-                    },
-                )
-                if response.status_code == 200:
-                    return True
-                else:
-                    logger.warning(f"Failed to log event: {response.status_code} {response.text}")
-                    return False
-        except Exception as e:
-            logger.warning(f"Failed to log event to Chronos: {e}")
-            return False
-
-    async def update_status(
-        self,
-        status: str,
-        message: str | None = None,
-        extra: dict[str, Any] | None = None,
-        api_key: str | None = None,
-    ) -> bool:
-        """Update the session status in Chronos.
-
-        Args:
-            status: New status (running, completed, failed)
-            message: Optional status message
-            extra: Optional additional data
-            api_key: API key for closing Plato session on terminal status
-
-        Returns:
-            True if status was updated successfully, False otherwise.
-        """
-        if not self._enabled:
-            return False
-
-        try:
-            async with httpx.AsyncClient(timeout=10.0) as client:
-                response = await client.post(
-                    f"{self.callback_url}/status",
-                    json={
-                        "session_id": self.session_id,
-                        "status": status,
-                        "message": message,
-                        "extra": extra,
-                        "api_key": api_key,
-                    },
-                )
-                return response.status_code == 200
-        except Exception as e:
-            logger.warning(f"Failed to update status in Chronos: {e}")
-            return False
-
-    def find_trajectory(self, logs_dir: str) -> dict[str, Any] | None:
-        """Find and load ATIF trajectory from logs directory.
-
-        Args:
-            logs_dir: Path to the logs directory
-
-        Returns:
-            Parsed ATIF trajectory dict if found, None otherwise.
-        """
-        trajectory_path = Path(logs_dir) / "agent" / "trajectory.json"
-
-        if not trajectory_path.exists():
-            logger.info(f"No trajectory file at {trajectory_path}")
-            return None
-
-        try:
-            with open(trajectory_path) as f:
-                data = json.load(f)
-                if isinstance(data, dict) and "schema_version" in data:
-                    logger.info(f"Found ATIF trajectory: {trajectory_path}")
-                    return data
-                logger.info(f"Trajectory file exists but no schema_version: {trajectory_path}")
-                return None
-        except Exception as e:
-            logger.warning(f"Failed to load trajectory from {trajectory_path}: {e}")
-            return None
-
-    def zip_logs_dir(self, logs_dir: str) -> bytes:
-        """Zip the entire logs directory.
-
-        Args:
-            logs_dir: Path to the logs directory
-
-        Returns:
-            Zip file contents as bytes.
-        """
-        logs_path = Path(logs_dir)
-        buffer = io.BytesIO()
-
-        with zipfile.ZipFile(buffer, "w", zipfile.ZIP_DEFLATED) as zf:
-            for file_path in logs_path.rglob("*"):
-                if file_path.is_file():
-                    arcname = file_path.relative_to(logs_path)
-                    zf.write(file_path, arcname)
-
-        buffer.seek(0)
-        return buffer.read()
-
-    async def upload_logs(self, logs_dir: str) -> str | None:
-        """Upload logs directory to S3 via Chronos.
-
-        Args:
-            logs_dir: Path to the logs directory
-
-        Returns:
-            S3 URL if successful, None otherwise.
-        """
-        if not self._enabled:
-            return None
-
-        try:
-            logs_zip = self.zip_logs_dir(logs_dir)
-            logs_base64 = base64.b64encode(logs_zip).decode("utf-8")
-            logger.info(f"Zipped logs: {len(logs_zip)} bytes")
-        except Exception as e:
-            logger.warning(f"Failed to zip logs: {e}")
-            return None
-
-        try:
-            async with httpx.AsyncClient(timeout=60.0) as client:
-                response = await client.post(
-                    f"{self.callback_url}/logs-upload",
-                    json={
-                        "session_id": self.session_id,
-                        "logs_base64": logs_base64,
-                    },
-                )
-                if response.status_code == 200:
-                    result = response.json()
-                    logger.info(f"Uploaded logs to Chronos: {result}")
-                    return result.get("logs_url")
-                else:
-                    logger.warning(f"Failed to upload logs: {response.status_code} {response.text}")
-                    return None
-        except Exception as e:
-            logger.warning(f"Failed to upload logs to Chronos: {e}")
-            return None
-
-    async def upload_artifacts(
-        self,
-        logs_dir: str,
-        trajectory: dict[str, Any] | None = None,
-        agent_image: str | None = None,
-    ) -> bool:
-        """Upload trajectory and logs to Chronos.
-
-        If trajectory is not provided, attempts to find it in the logs directory.
-
-        Args:
-            logs_dir: Path to the logs directory
-            trajectory: Optional pre-loaded trajectory dict.
-            agent_image: Optional agent Docker image URI to include in trajectory.
-
-        Returns:
-            True if successful, False otherwise.
-        """
-        if not self._enabled:
-            return False
-
-        success = False
-
-        # Find and upload trajectory
-        if trajectory is None:
-            trajectory = self.find_trajectory(logs_dir)
-
-        if trajectory:
-            # Merge agent image into trajectory
-            if agent_image:
-                agent = trajectory.get("agent", {})
-                extra = agent.get("extra") or {}
-                extra["image"] = agent_image
-                agent["extra"] = extra
-                trajectory["agent"] = agent
-
-            logger.info("Uploading trajectory to Chronos")
-            if await self.log_event(
-                span_type="trajectory",
-                log_type="atif",
-                extra=trajectory,
-                source="agent",
-            ):
-                logger.info("Trajectory uploaded successfully")
-                success = True
-            else:
-                logger.warning("Failed to upload trajectory")
-
-        # Upload logs
-        logs_url = await self.upload_logs(logs_dir)
-        if logs_url:
-            logger.info(f"Logs uploaded: {logs_url}")
-            success = True
-
-        return success
-
-    # Legacy methods for backwards compatibility
-
-    async def push_logs(self, logs: list[dict[str, Any]]) -> bool:
-        """Legacy: Push log entries (just acknowledges now)."""
-        if not self._enabled:
-            return False
-        try:
-            async with httpx.AsyncClient(timeout=10.0) as client:
-                response = await client.post(
-                    f"{self.callback_url}/logs",
-                    json={"session_id": self.session_id, "logs": logs},
-                )
-                return response.status_code == 200
-        except Exception:
-            return False
-
-    async def push_log(
-        self,
-        message: str,
-        level: str = "info",
-        extra: dict[str, Any] | None = None,
-    ) -> bool:
-        """Legacy: Push a single log entry."""
-        log_entry: dict[str, Any] = {"level": level, "message": message}
-        if extra:
-            log_entry["extra"] = extra
-        return await self.push_logs([log_entry])