coze-coding-dev-sdk 0.5.14__tar.gz → 0.5.15__tar.gz

{coze_coding_dev_sdk-0.5.14/coze_coding_dev_sdk.egg-info → coze_coding_dev_sdk-0.5.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coze-coding-dev-sdk
-Version: 0.5.14
+Version: 0.5.15
 Summary: Coze Coding Dev SDK - 优雅的多功能 AI SDK，支持图片生成、视频生成、语音合成、语音识别、大语言模型、联网搜索和文本/多模态 Embedding。包含命令行工具 coze-coding-ai，支持 Context 上下文追踪
 Author-email: Coze Coding Integration Team <support@coze.com>
 Maintainer-email: Coze Coding Integration Team <support@coze.com>

{coze_coding_dev_sdk-0.5.14 → coze_coding_dev_sdk-0.5.15}/coze_coding_dev_sdk/__init__.py

@@ -76,6 +76,16 @@ from .fetch import (
     FetchResponse,
 )
 
+from .report import (
+    LogEntry,
+    ReportClient,
+    ReportBuffer,
+    get_report_buffer,
+    InstrumentedTransport,
+    InstrumentedAsyncTransport,
+    create_boto3_report_hooks,
+)
+
 __version__ = "0.5.0"
 
 __all__ = [
@@ -150,4 +160,11 @@ __all__ = [
     "FetchImage",
     "FetchRequest",
     "FetchResponse",
+    "LogEntry",
+    "ReportClient",
+    "ReportBuffer",
+    "get_report_buffer",
+    "InstrumentedTransport",
+    "InstrumentedAsyncTransport",
+    "create_boto3_report_hooks",
 ]

coze_coding_dev_sdk-0.5.15/coze_coding_dev_sdk/report/__init__.py

@@ -0,0 +1,19 @@
+from .models import LogEntry
+from .utils import truncate, redact_url
+from .client import ReportClient
+from .buffer import ReportBuffer
+from .singleton import get_report_buffer
+from .interceptors.httpx_transport import InstrumentedTransport, InstrumentedAsyncTransport
+from .interceptors.boto3_hook import create_boto3_report_hooks
+
+__all__ = [
+    "LogEntry",
+    "truncate",
+    "redact_url",
+    "ReportClient",
+    "ReportBuffer",
+    "get_report_buffer",
+    "InstrumentedTransport",
+    "InstrumentedAsyncTransport",
+    "create_boto3_report_hooks",
+]

coze_coding_dev_sdk-0.5.15/coze_coding_dev_sdk/report/buffer.py

@@ -0,0 +1,114 @@
+import atexit
+import os
+import threading
+import time
+from collections import deque
+from typing import List, Optional
+
+from .models import LogEntry
+
+BUFFER_SIZE_THRESHOLD = 100
+FLUSH_INTERVAL_SECONDS = 60.0
+MAX_BUFFER_SIZE = 60_000
+MAX_FLUSH_RETRIES = 3
+FLUSH_RETRY_BASE_SECONDS = 1.0
+
+
+class ReportBuffer:
+    def __init__(self, client):
+        self._client = client
+        self._buffer: deque[LogEntry] = deque(maxlen=MAX_BUFFER_SIZE)
+        self._lock = threading.Lock()
+        self._project_id: Optional[str] = os.environ.get("COZELOOP_WORKSPACE_ID")
+        self._env: Optional[str] = os.environ.get("COZE_PROJECT_ENV")
+        self._timer: Optional[threading.Timer] = None
+        self._destroyed = False
+        self._flushing = False
+        self._pending_flush = False
+        self._start_timer()
+        atexit.register(self.destroy)
+
+    def _start_timer(self) -> None:
+        with self._lock:
+            if self._destroyed:
+                return
+            self._timer = threading.Timer(FLUSH_INTERVAL_SECONDS, self._on_timer)
+            self._timer.daemon = True
+            self._timer.start()
+
+    def _on_timer(self) -> None:
+        try:
+            self.flush()
+        except Exception:
+            pass
+        self._start_timer()
+
+    def add(self, entry: LogEntry) -> None:
+        if self._destroyed:
+            return
+        try:
+            with self._lock:
+                entry.project_id = self._project_id
+                entry.env = self._env
+                self._buffer.append(entry)
+                should_flush = len(self._buffer) >= BUFFER_SIZE_THRESHOLD
+            if should_flush:
+                t = threading.Thread(target=self.flush, daemon=True)
+                t.start()
+        except Exception:
+            pass
+
+    def flush(self) -> None:
+        with self._lock:
+            if self._flushing:
+                self._pending_flush = True
+                return
+            if not self._buffer:
+                return
+            self._flushing = True
+
+        consecutive_failures = 0
+        try:
+            while True:
+                with self._lock:
+                    count = min(BUFFER_SIZE_THRESHOLD, len(self._buffer))
+                    if count == 0:
+                        break
+                    entries: List[LogEntry] = [self._buffer.popleft() for _ in range(count)]
+
+                try:
+                    self._client.batch_report(entries)
+                    consecutive_failures = 0
+                except Exception as e:
+                    consecutive_failures += 1
+                    with self._lock:
+                        for entry in reversed(entries):
+                            if len(self._buffer) < MAX_BUFFER_SIZE:
+                                self._buffer.appendleft(entry)
+                    if consecutive_failures >= MAX_FLUSH_RETRIES:
+                        print(f"[report] flush failed {consecutive_failures} times, giving up until next cycle: {e}")
+                        break
+                    delay = FLUSH_RETRY_BASE_SECONDS * (2 ** (consecutive_failures - 1))
+                    print(f"[report] flush failed (attempt {consecutive_failures}/{MAX_FLUSH_RETRIES}), retrying in {delay}s: {e}")
+                    time.sleep(delay)
+                    continue
+
+                with self._lock:
+                    if not self._pending_flush and len(self._buffer) < BUFFER_SIZE_THRESHOLD:
+                        break
+                    self._pending_flush = False
+        finally:
+            with self._lock:
+                self._flushing = False
+                self._pending_flush = False
+
+    def destroy(self) -> None:
+        with self._lock:
+            self._destroyed = True
+            if self._timer:
+                self._timer.cancel()
+                self._timer = None
+        try:
+            self.flush()
+        except Exception:
+            pass

coze_coding_dev_sdk-0.5.15/coze_coding_dev_sdk/report/client.py

@@ -0,0 +1,96 @@
+import os
+from typing import List, Optional, Dict, Tuple
+
+from .models import LogEntry
+
+BATCH_REPORT_TIMEOUT_SECONDS = 10
+
+_env_loaded = False
+_cached_env: Tuple[str, str] = ("", "")
+
+
+def _load_report_env() -> Tuple[str, str]:
+    """Load base_url and api_key from env, dotenv, or coze_workload_identity."""
+    global _env_loaded, _cached_env
+    if _env_loaded:
+        return _cached_env
+
+    base_url = os.environ.get("COZE_INTEGRATION_BASE_URL", "")
+    api_key = os.environ.get("COZE_WORKLOAD_IDENTITY_API_KEY", "")
+
+    if base_url and api_key:
+        _env_loaded = True
+        _cached_env = (base_url, api_key)
+        return _cached_env
+
+    try:
+        from dotenv import load_dotenv
+        load_dotenv()
+        base_url = os.environ.get("COZE_INTEGRATION_BASE_URL", "")
+        api_key = os.environ.get("COZE_WORKLOAD_IDENTITY_API_KEY", "")
+        if base_url and api_key:
+            _env_loaded = True
+            _cached_env = (base_url, api_key)
+            return _cached_env
+    except ImportError:
+        pass
+
+    try:
+        from coze_workload_identity import Client
+        client = Client()
+        env_vars = client.get_project_env_vars()
+        client.close()
+        for env_var in env_vars:
+            if env_var.key == "COZE_INTEGRATION_BASE_URL":
+                base_url = env_var.value
+            elif env_var.key == "COZE_WORKLOAD_IDENTITY_API_KEY":
+                api_key = env_var.value
+    except Exception:
+        pass
+
+    _env_loaded = True
+    _cached_env = (base_url, api_key)
+    return _cached_env
+
+
+class ReportClient:
+    def __init__(self):
+        try:
+            base_url, api_key = _load_report_env()
+            self._base_url = base_url
+            self._api_key = api_key
+            self._configured = bool(self._base_url and self._api_key)
+            if not self._configured:
+                missing = []
+                if not self._base_url:
+                    missing.append("COZE_INTEGRATION_BASE_URL")
+                if not self._api_key:
+                    missing.append("COZE_WORKLOAD_IDENTITY_API_KEY")
+                print(f"[report] ReportClient not configured: {', '.join(missing)} is missing")
+        except Exception as e:
+            self._base_url = None
+            self._api_key = None
+            self._configured = False
+            print(f"[report] ReportClient config failed: {e}")
+
+    def batch_report(self, entries: List[LogEntry]) -> None:
+        if not entries:
+            return
+        if not self._configured:
+            print(f"[report] batchReport skipped: ReportClient is not configured. "
+                  f"Set COZE_INTEGRATION_BASE_URL and COZE_WORKLOAD_IDENTITY_API_KEY "
+                  f"environment variables. Dropping {len(entries)} entries.")
+            return
+        # Use `requests` instead of `httpx` intentionally to avoid self-instrumentation:
+        # the SDK wraps httpx transports for report interception, so using httpx here
+        # would cause the reporting calls themselves to be intercepted recursively.
+        import requests
+
+        url = f"{self._base_url}/v1/memory_report/batch_report"
+        headers: Dict[str, str] = {
+            "Content-Type": "application/json",
+            "x-coze-token": self._api_key,
+        }
+        payload = {"entries": [e.model_dump() for e in entries]}
+        resp = requests.post(url, json=payload, headers=headers, timeout=BATCH_REPORT_TIMEOUT_SECONDS)
+        resp.raise_for_status()

coze_coding_dev_sdk-0.5.15/coze_coding_dev_sdk/report/interceptors/__init__.py

@@ -0,0 +1,4 @@
+from .httpx_transport import InstrumentedTransport, InstrumentedAsyncTransport
+from .boto3_hook import create_boto3_report_hooks
+
+__all__ = ["InstrumentedTransport", "InstrumentedAsyncTransport", "create_boto3_report_hooks"]

coze_coding_dev_sdk-0.5.15/coze_coding_dev_sdk/report/interceptors/boto3_hook.py

@@ -0,0 +1,127 @@
+import threading
+import time
+from typing import Optional
+
+from ..buffer import ReportBuffer
+from ..models import LogEntry
+from ..utils import redact_url, truncate
+
+
+def create_boto3_report_hooks(buffer: ReportBuffer, source: str = "s3"):
+    # We use thread_id to correlate before/after hooks because boto3's event
+    # system does not pass a request-level correlation ID between hooks.
+    # Limitation: thread ident can be reused in thread pools after a thread dies,
+    # and nested boto3 calls on the same thread will overwrite the pending entry.
+    # A periodic cleanup discards stale entries older than 5 minutes.
+    _pending = {}
+    _pending_lock = threading.Lock()
+    _STALE_THRESHOLD = 300  # 5 minutes
+
+    def _cleanup_stale():
+        """Remove pending entries older than _STALE_THRESHOLD seconds."""
+        now = time.time()
+        stale_keys = [k for k, v in _pending.items() if now - v["start_time"] > _STALE_THRESHOLD]
+        for k in stale_keys:
+            _pending.pop(k, None)
+
+    def before_hook(event_name, params, **kwargs):
+        try:
+            thread_id = threading.current_thread().ident
+            url_parts = []
+            if "url" in params:
+                url_parts.append(params["url"])
+            elif "endpoint_url" in kwargs:
+                url_parts.append(kwargs["endpoint_url"])
+
+            method = (params.get("method") or params.get("http_method") or "UNKNOWN") if isinstance(params, dict) else "UNKNOWN"
+
+            request_body: Optional[str] = None
+            body = params.get("body") if isinstance(params, dict) else None
+            if body:
+                try:
+                    if isinstance(body, bytes):
+                        request_body = truncate(body.decode("utf-8", errors="replace"))
+                    elif isinstance(body, str):
+                        request_body = truncate(body)
+                except Exception:
+                    pass
+
+            with _pending_lock:
+                _cleanup_stale()
+                _pending[thread_id] = {
+                    "start_time": time.time(),
+                    "method": method,
+                    "url": url_parts[0] if url_parts else "",
+                    "request_body": request_body,
+                }
+        except Exception:
+            pass
+
+    def after_hook(event_name, parsed, **kwargs):
+        try:
+            thread_id = threading.current_thread().ident
+            with _pending_lock:
+                pending = _pending.pop(thread_id, None)
+            if pending is None:
+                return
+
+            duration_ms = (time.time() - pending["start_time"]) * 1000
+            http_response = kwargs.get("http_response")
+            status_code: Optional[int] = None
+            if http_response is not None:
+                status_code = getattr(http_response, "status_code", None)
+
+            success = 200 <= status_code < 300 if status_code else False
+
+            response_body: Optional[str] = None
+            if parsed:
+                try:
+                    import json
+                    response_body = truncate(json.dumps(parsed, default=str))
+                except Exception:
+                    pass
+
+            entry = LogEntry(
+                source=source,
+                method=pending["method"],
+                url=redact_url(pending["url"]),
+                request_body=pending.get("request_body"),
+                response_body=response_body,
+                status_code=status_code,
+                error=None,
+                duration_ms=duration_ms,
+                timestamp=int(pending["start_time"] * 1000),
+                success=success,
+            )
+            buffer.add(entry)
+        except Exception:
+            pass
+
+    def error_hook(event_name, exception, **kwargs):
+        """Handle failed S3 requests: clean up _pending and log the error."""
+        try:
+            thread_id = threading.current_thread().ident
+            with _pending_lock:
+                pending = _pending.pop(thread_id, None)
+            if pending is None:
+                return
+
+            duration_ms = (time.time() - pending["start_time"]) * 1000
+
+            entry = LogEntry(
+                source=source,
+                method=pending["method"],
+                url=redact_url(pending["url"]),
+                request_body=pending.get("request_body"),
+                response_body=None,
+                status_code=None,
+                error=str(exception) if exception else "Unknown error",
+                duration_ms=duration_ms,
+                timestamp=int(pending["start_time"] * 1000),
+                success=False,
+            )
+            buffer.add(entry)
+        except Exception:
+            pass
+
+    return before_hook, after_hook, error_hook

coze_coding_dev_sdk-0.5.15/coze_coding_dev_sdk/report/interceptors/httpx_transport.py

@@ -0,0 +1,97 @@
+import time
+from typing import Optional
+
+import httpx
+
+from ..buffer import ReportBuffer
+from ..models import LogEntry
+from ..utils import redact_url, truncate
+
+
+def _safe_record(
+    buffer: ReportBuffer,
+    source: str,
+    request: httpx.Request,
+    response: Optional[httpx.Response],
+    error: Optional[Exception],
+    start_time: float,
+) -> None:
+    try:
+        duration_ms = (time.time() - start_time) * 1000
+        status_code = response.status_code if response else None
+        success = 200 <= status_code < 300 if status_code else False
+
+        request_body: Optional[str] = None
+        try:
+            raw = request.content
+            if raw:
+                request_body = truncate(raw.decode("utf-8", errors="replace"))
+        except Exception:
+            pass
+
+        response_body: Optional[str] = None
+        if response is not None:
+            try:
+                response_body = truncate(response.text)
+            except Exception:
+                pass
+
+        entry = LogEntry(
+            source=source,
+            method=request.method,
+            url=redact_url(str(request.url)),
+            request_body=request_body,
+            response_body=response_body,
+            status_code=status_code,
+            error=str(error) if error else None,
+            duration_ms=duration_ms,
+            timestamp=int(start_time * 1000),
+            success=success,
+        )
+        buffer.add(entry)
+    except Exception as e:
+        print(f"[report] _safe_record error: {e}")
+
+
+class InstrumentedTransport(httpx.BaseTransport):
+    def __init__(
+        self,
+        transport: httpx.BaseTransport,
+        buffer: ReportBuffer,
+        source: str = "supabase",
+    ):
+        self._transport = transport
+        self._buffer = buffer
+        self._source = source
+
+    def handle_request(self, request: httpx.Request) -> httpx.Response:
+        start_time = time.time()
+        try:
+            response = self._transport.handle_request(request)
+            _safe_record(self._buffer, self._source, request, response, None, start_time)
+            return response
+        except Exception as exc:
+            _safe_record(self._buffer, self._source, request, None, exc, start_time)
+            raise
+
+
+class InstrumentedAsyncTransport(httpx.AsyncBaseTransport):
+    def __init__(
+        self,
+        transport: httpx.AsyncBaseTransport,
+        buffer: ReportBuffer,
+        source: str = "supabase",
+    ):
+        self._transport = transport
+        self._buffer = buffer
+        self._source = source
+
+    async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
+        start_time = time.time()
+        try:
+            response = await self._transport.handle_async_request(request)
+            _safe_record(self._buffer, self._source, request, response, None, start_time)
+            return response
+        except Exception as exc:
+            _safe_record(self._buffer, self._source, request, None, exc, start_time)
+            raise

coze_coding_dev_sdk-0.5.15/coze_coding_dev_sdk/report/models.py

@@ -0,0 +1,18 @@
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class LogEntry(BaseModel):
+    source: str
+    project_id: Optional[str] = None
+    env: Optional[str] = None
+    method: str
+    url: str
+    request_body: Optional[str] = None
+    response_body: Optional[str] = None
+    status_code: Optional[int] = None
+    error: Optional[str] = None
+    duration_ms: float
+    timestamp: int
+    success: bool

coze_coding_dev_sdk-0.5.15/coze_coding_dev_sdk/report/singleton.py

@@ -0,0 +1,24 @@
+import threading
+from typing import Optional
+
+from .buffer import ReportBuffer
+from .client import ReportClient
+
+_buffer: Optional[ReportBuffer] = None
+_lock = threading.Lock()
+
+
+def get_report_buffer() -> Optional[ReportBuffer]:
+    global _buffer
+    if _buffer is not None:
+        return _buffer
+    with _lock:
+        if _buffer is not None:
+            return _buffer
+        try:
+            client = ReportClient()
+            _buffer = ReportBuffer(client)
+            return _buffer
+        except Exception as e:
+            print(f"[report] failed to create singleton buffer: {e}")
+            return None

coze_coding_dev_sdk-0.5.15/coze_coding_dev_sdk/report/utils.py

@@ -0,0 +1,21 @@
+import re
+from typing import Optional
+
+_SENSITIVE_PARAM_RE = re.compile(
+    r'((?:apikey|api_key|access_key|secret_key|access_token|token|secret|password|authorization|credential|X-Amz-Signature|X-Amz-Credential|X-Amz-Security-Token)=)[^&]*',
+    re.IGNORECASE,
+)
+
+DEFAULT_TRUNCATE_LENGTH = 1024
+
+
+def truncate(s: Optional[str], max_len: int = DEFAULT_TRUNCATE_LENGTH) -> Optional[str]:
+    if s is None:
+        return None
+    if len(s) <= max_len:
+        return s
+    return s[:max_len] + "...[truncated]"
+
+
+def redact_url(url: str) -> str:
+    return _SENSITIVE_PARAM_RE.sub(r'\1***', url)

{coze_coding_dev_sdk-0.5.14 → coze_coding_dev_sdk-0.5.15}/coze_coding_dev_sdk/s3/client.py

@@ -119,6 +119,17 @@ class S3SyncStorage:
                     logger.error("Error loading COZE_WORKLOAD_IDENTITY_TOKEN: %s", e)
 
             client.meta.events.register("before-call.s3", _inject_header)
+            try:
+                from ..report import get_report_buffer, create_boto3_report_hooks
+
+                report_buffer = get_report_buffer()
+                if report_buffer:
+                    before_hook, after_hook, error_hook = create_boto3_report_hooks(report_buffer, source="s3")
+                    client.meta.events.register("before-call.s3", before_hook)
+                    client.meta.events.register("after-call.s3", after_hook)
+                    client.meta.events.register("after-call-error.s3", error_hook)
+            except Exception:
+                pass
             self._client = client
         return self._client
 

{coze_coding_dev_sdk-0.5.14 → coze_coding_dev_sdk-0.5.15/coze_coding_dev_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coze-coding-dev-sdk
-Version: 0.5.14
+Version: 0.5.15
 Summary: Coze Coding Dev SDK - 优雅的多功能 AI SDK，支持图片生成、视频生成、语音合成、语音识别、大语言模型、联网搜索和文本/多模态 Embedding。包含命令行工具 coze-coding-ai，支持 Context 上下文追踪
 Author-email: Coze Coding Integration Team <support@coze.com>
 Maintainer-email: Coze Coding Integration Team <support@coze.com>

{coze_coding_dev_sdk-0.5.14 → coze_coding_dev_sdk-0.5.15}/coze_coding_dev_sdk.egg-info/SOURCES.txt

@@ -57,6 +57,15 @@ coze_coding_dev_sdk/llm/client.py
 coze_coding_dev_sdk/llm/models.py
 coze_coding_dev_sdk/memory/__init__.py
 coze_coding_dev_sdk/memory/client.py
+coze_coding_dev_sdk/report/__init__.py
+coze_coding_dev_sdk/report/buffer.py
+coze_coding_dev_sdk/report/client.py
+coze_coding_dev_sdk/report/models.py
+coze_coding_dev_sdk/report/singleton.py
+coze_coding_dev_sdk/report/utils.py
+coze_coding_dev_sdk/report/interceptors/__init__.py
+coze_coding_dev_sdk/report/interceptors/boto3_hook.py
+coze_coding_dev_sdk/report/interceptors/httpx_transport.py
 coze_coding_dev_sdk/s3/__init__.py
 coze_coding_dev_sdk/s3/client.py
 coze_coding_dev_sdk/s3/models.py

{coze_coding_dev_sdk-0.5.14 → coze_coding_dev_sdk-0.5.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "coze-coding-dev-sdk"
-version = "0.5.14"
+version = "0.5.15"
 description = "Coze Coding Dev SDK - 优雅的多功能 AI SDK，支持图片生成、视频生成、语音合成、语音识别、大语言模型、联网搜索和文本/多模态 Embedding。包含命令行工具 coze-coding-ai，支持 Context 上下文追踪"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -98,7 +98,7 @@ dev = [
 ]
 
 [tool.setuptools]
-packages = ["coze_coding_dev_sdk", "coze_coding_dev_sdk.core", "coze_coding_dev_sdk.image", "coze_coding_dev_sdk.video", "coze_coding_dev_sdk.voice", "coze_coding_dev_sdk.llm", "coze_coding_dev_sdk.search", "coze_coding_dev_sdk.cli", "coze_coding_dev_sdk.database", "coze_coding_dev_sdk.memory", "coze_coding_dev_sdk.s3", "coze_coding_dev_sdk.embedding", "coze_coding_dev_sdk.supabase"]
+packages = ["coze_coding_dev_sdk", "coze_coding_dev_sdk.core", "coze_coding_dev_sdk.image", "coze_coding_dev_sdk.video", "coze_coding_dev_sdk.voice", "coze_coding_dev_sdk.llm", "coze_coding_dev_sdk.search", "coze_coding_dev_sdk.cli", "coze_coding_dev_sdk.database", "coze_coding_dev_sdk.memory", "coze_coding_dev_sdk.s3", "coze_coding_dev_sdk.embedding", "coze_coding_dev_sdk.supabase", "coze_coding_dev_sdk.report", "coze_coding_dev_sdk.report.interceptors"]
 
 [tool.setuptools.package-data]
 coze_coding_dev_sdk = ["py.typed"]