logs-sdk 0.3.0__py3-none-any.whl

logs_sdk/__init__.py

@@ -0,0 +1,15 @@
+"""日志管理平台 Python SDK — FastAPI/Starlette/Flask 中间件，一行代码接入日志采集。
+
+使用方法:
+    from logs_sdk import LogSDK
+    logger = LogSDK(endpoint="https://api.logs.codexs.cn/api/v1/ingest/logs",
+                    api_key="clog_pk_xxx", api_secret="clog_sk_xxx",
+                    project_slug="my-project")
+    app.add_middleware(logger.fastapi_middleware)  # FastAPI
+"""
+
+from .client import LogSDK
+from .types import LogEntry, LogConfig
+
+__version__ = "0.3.0"
+__all__ = ["LogSDK", "LogEntry", "LogConfig"]

logs_sdk/buffer.py

@@ -0,0 +1,42 @@
+"""环形缓冲区 — 80% 自动触发 flush"""
+import threading
+from typing import List, Callable
+from .types import LogEntry
+
+class RingBuffer:
+    def __init__(self, capacity: int, flush_fn: Callable):
+        self.capacity = max(capacity, 100)
+        self.buf = [None] * self.capacity
+        self.head = 0
+        self.tail = 0
+        self.count = 0
+        self.lock = threading.Lock()
+        self.flush_fn = flush_fn
+
+    def push(self, entry: LogEntry):
+        with self.lock:
+            self.buf[self.head] = entry
+            self.head = (self.head + 1) % self.capacity
+            self.count += 1
+            if self.count >= self.capacity * 0.8:
+                entries = self._drain()
+                if self.flush_fn:
+                    self.flush_fn(entries)
+
+    def flush(self) -> List[LogEntry]:
+        with self.lock:
+            return self._drain()
+
+    @property
+    def length(self) -> int:
+        return self.count
+
+    def _drain(self) -> List[LogEntry]:
+        entries = []
+        while self.count > 0:
+            if self.buf[self.tail]:
+                entries.append(self.buf[self.tail])
+            self.buf[self.tail] = None
+            self.tail = (self.tail + 1) % self.capacity
+            self.count -= 1
+        return entries

logs_sdk/client.py

@@ -0,0 +1,92 @@
+"""核心客户端 — 缓冲管理、定时刷新、HTTP 上报、离线缓存"""
+import json, time, os, socket, threading, logging
+import httpx
+from .types import LogConfig, LogEntry, new_uuid
+from .buffer import RingBuffer
+from .offline import OfflineCache
+
+logger = logging.getLogger("logs-sdk")
+
+class LogSDK:
+    def __init__(self, **kwargs):
+        self.config = LogConfig(**{k: v for k, v in kwargs.items() if k in LogConfig.__dataclass_fields__})
+        self.hostname = socket.gethostname()
+        self.pid = str(os.getpid())
+        self.offline_cache = OfflineCache()
+        self._closed = False
+        self._lock = threading.Lock()
+
+        self.buffer = RingBuffer(self.config.buffer_size, self._flush_entries)
+        self._timer: threading.Timer | None = None
+        self._start_flush_timer()
+
+    def send(self, entry: LogEntry):
+        """异步发送一条日志"""
+        if self._closed:
+            logger.warning("Client 已关闭，日志丢弃")
+            return
+        entry.host = self.hostname
+        entry.process_id = self.pid
+        entry.environment = self.config.environment
+        entry.project_slug = self.config.project_slug
+        entry.service_name = self.config.service_name
+        entry.timestamp = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+        self.buffer.push(entry)
+
+    def close(self):
+        """优雅关闭"""
+        self._closed = True
+        if self._timer:
+            self._timer.cancel()
+        remaining = self.buffer.flush()
+        if remaining:
+            try:
+                self._send_batch(remaining)
+            except Exception as e:
+                logger.error(f"关闭时上报失败: {e}")
+                self.offline_cache.save(remaining)
+        self.offline_cache.flush_all(self._send_batch)
+
+    def fastapi_middleware(self):
+        """返回 FastAPI/Starlette 中间件"""
+        from .middleware import FastAPIMiddleware
+        return FastAPIMiddleware(self)
+
+    def flask_middleware(self):
+        """返回 Flask 中间件（预留）"""
+        raise NotImplementedError("Flask 中间件将在下一个版本支持")
+
+    def _flush_entries(self, entries):
+        """异步发送（在单独线程中执行）"""
+        threading.Thread(target=self._flush_sync, args=(entries,), daemon=True).start()
+
+    def _flush_sync(self, entries):
+        for attempt in range(self.config.max_retries + 1):
+            try:
+                self._send_batch(entries)
+                return
+            except Exception as e:
+                if attempt == self.config.max_retries:
+                    logger.error(f"上报失败(重试{self.config.max_retries}次): {e}")
+                    self.offline_cache.save(entries)
+                else:
+                    time.sleep(0.5 * (2 ** attempt))
+
+    def _send_batch(self, entries):
+        body = json.dumps({"logs": [e.to_dict() for e in entries]})
+        resp = httpx.post(self.config.endpoint, content=body,
+            headers={"Content-Type": "application/json", "X-API-Key": self.config.api_key,
+                     "X-SDK-Type": "python", "X-SDK-Version": "0.3.0"},
+            timeout=15)
+        if resp.status_code not in (200, 201):
+            raise Exception(f"服务端返回 {resp.status_code}")
+
+    def _start_flush_timer(self):
+        def _loop():
+            while not self._closed:
+                time.sleep(self.config.flush_interval)
+                if self._closed: break
+                entries = self.buffer.flush()
+                if entries:
+                    self._flush_entries(entries)
+        threading.Thread(target=_loop, daemon=True).start()

logs_sdk/middleware.py

@@ -0,0 +1,142 @@
+"""FastAPI/Starlette/Flask 中间件 — 自动采集所有 HTTP 请求日志"""
+import time, traceback, sys, json
+from .types import LogEntry, new_uuid, detect_client_type, detect_origin, sanitize_headers, extract_api_version
+
+
+class FastAPIMiddleware:
+    """Starlette BaseHTTPMiddleware 实现，兼容 FastAPI"""
+
+    def __init__(self, sdk):
+        self.sdk = sdk
+
+    async def dispatch(self, request, call_next):
+        entry = LogEntry()
+        entry.uuid = new_uuid()
+        entry.request_id = entry.uuid[:8]
+        entry.trace_id = entry.uuid
+        entry.span_id = entry.uuid
+        start = time.time()
+
+        # 读取请求体（缓存以支持多次读取）
+        body_bytes = b""
+        try:
+            body_bytes = await request.body()
+        except Exception:
+            pass
+
+        # 请求信息
+        headers = dict(request.headers)
+        entry.method = request.method
+        entry.scheme = request.url.scheme
+        entry.full_url = str(request.url)
+        entry.host_header = request.headers.get("host", "")
+        entry.path = request.url.path
+        entry.query_string = request.url.query
+        entry.content_type = request.headers.get("content-type", "")
+        entry.user_agent = request.headers.get("user-agent", "")
+        entry.client_ip = headers.get("x-forwarded-for", request.client.host if request.client else "")
+        entry.client_ip_chain = headers.get("x-forwarded-for", "")
+        entry.client_type = detect_client_type(entry.user_agent, headers)
+        entry.origin = detect_origin(headers, entry.user_agent)
+        entry.request_headers = sanitize_headers(headers)
+        entry.request_body = body_bytes[:self.sdk.config.max_body_size].decode("utf-8", errors="replace")
+        entry.request_body_size = len(body_bytes)
+        entry.referer = request.headers.get("referer", "")
+        entry.trace_id = headers.get("x-trace-id", entry.uuid)
+        entry.parent_span_id = headers.get("x-parent-span-id", "")
+        entry.user_id = headers.get("x-user-id", "")
+        entry.session_id = headers.get("x-session-id", "")
+        entry.api_version = extract_api_version(entry.path)
+        entry.proto = request.scope.get("http_version", "1.1")
+        entry.tls_version = getattr(request.scope.get("transport"), "get_extra_info", lambda x: "")(f"tls_version") or ""
+
+        # 执行业务
+        try:
+            response = await call_next(request)
+        except Exception as e:
+            entry.is_error = True
+            entry.error_type = "panic"
+            entry.error_message = str(e)
+            entry.error_stack = traceback.format_exc()
+            raise
+        finally:
+            entry.duration_ms = int((time.time() - start) * 1000)
+
+        # 响应信息
+        entry.status_code = getattr(response, "status_code", 200)
+        resp_headers = dict(getattr(response, "headers", {}))
+        entry.response_headers = sanitize_headers(resp_headers)
+        entry.response_body_size = int(resp_headers.get("content-length", 0)) if resp_headers.get("content-length") else 0
+
+        if entry.status_code >= 500:
+            entry.is_error = True
+            entry.error_type = "http_error"
+
+        self.sdk.send(entry)
+        return response
+
+
+class FlaskMiddleware:
+    """Flask WSGI 中间件"""
+
+    def __init__(self, sdk):
+        self.sdk = sdk
+
+    def __call__(self, environ, start_response):
+        entry = LogEntry()
+        entry.uuid = new_uuid()
+        entry.request_id = entry.uuid[:8]
+        entry.trace_id = entry.uuid
+        entry.span_id = entry.uuid
+        start = time.time()
+
+        entry.method = environ.get("REQUEST_METHOD", "")
+        entry.scheme = environ.get("wsgi.url_scheme", "http")
+        entry.host_header = environ.get("HTTP_HOST", "")
+        entry.path = environ.get("PATH_INFO", "")
+        entry.query_string = environ.get("QUERY_STRING", "")
+        entry.full_url = f"{entry.scheme}://{entry.host_header}{entry.path}" + (f"?{entry.query_string}" if entry.query_string else "")
+        entry.user_agent = environ.get("HTTP_USER_AGENT", "")
+        entry.client_ip = environ.get("HTTP_X_FORWARDED_FOR", environ.get("REMOTE_ADDR", ""))
+        entry.content_type = environ.get("CONTENT_TYPE", "")
+
+        headers = {k.replace("HTTP_", "").lower().replace("_", "-"): v for k, v in environ.items() if k.startswith("HTTP_")}
+        entry.client_type = detect_client_type(entry.user_agent, headers)
+        entry.origin = detect_origin(headers, entry.user_agent)
+        entry.request_headers = sanitize_headers(headers)
+        entry.api_version = extract_api_version(entry.path)
+
+        # 读取请求体
+        try:
+            body = environ["wsgi.input"].read(self.sdk.config.max_body_size)
+            entry.request_body = body.decode("utf-8", errors="replace")
+            entry.request_body_size = len(body)
+        except Exception:
+            pass
+
+        status_code = 200
+
+        def _start_response(status, response_headers, exc_info=None):
+            nonlocal status_code
+            status_code = int(status.split()[0])
+            resp_headers = {k.lower(): v for k, v in response_headers}
+            entry.response_headers = sanitize_headers(resp_headers)
+            return start_response(status, response_headers, exc_info)
+
+        try:
+            response_iter = self.sdk.app(environ, _start_response)
+            entry.duration_ms = int((time.time() - start) * 1000)
+            entry.status_code = status_code
+            if status_code >= 500:
+                entry.is_error = True
+                entry.error_type = "http_error"
+            self.sdk.send(entry)
+            return response_iter
+        except Exception as e:
+            entry.is_error = True
+            entry.error_type = "panic"
+            entry.error_message = str(e)
+            entry.error_stack = traceback.format_exc()
+            entry.duration_ms = int((time.time() - start) * 1000)
+            self.sdk.send(entry)
+            raise

logs_sdk/offline.py

@@ -0,0 +1,57 @@
+"""离线缓存 — 网络故障时缓存到本地文件，恢复后自动重传"""
+import json, os, tempfile, time, logging
+from typing import List, Callable
+from .types import LogEntry
+
+logger = logging.getLogger("logs-sdk")
+
+class OfflineCache:
+    def __init__(self, directory: str = ""):
+        self.dir = directory or os.path.join(tempfile.gettempdir(), "logs-sdk-offline")
+        self.max_size = 50 * 1024 * 1024
+        self.max_age = 24 * 3600
+        self.enabled = True
+        os.makedirs(self.dir, exist_ok=True)
+
+    def save(self, entries: List[LogEntry]):
+        if not self.enabled or not entries: return
+        self._cleanup()
+        filename = os.path.join(self.dir, f"offline-{time.strftime('%Y%m%dT%H%M%S')}.json")
+        try:
+            with open(filename, "w") as f:
+                json.dump([e.to_dict() for e in entries], f)
+            logger.info(f"离线缓存已保存: {filename} ({len(entries)} 条)")
+        except Exception as e:
+            logger.error(f"离线缓存保存失败: {e}")
+
+    def flush_all(self, send_fn: Callable):
+        files = [f for f in os.listdir(self.dir) if f.startswith("offline-") and f.endswith(".json")]
+        if not files: return
+        for fn in sorted(files):
+            filepath = os.path.join(self.dir, fn)
+            try:
+                if time.time() - os.path.getmtime(filepath) > self.max_age:
+                    os.remove(filepath)
+                    continue
+                with open(filepath) as f:
+                    data = json.load(f)
+                entries = [LogEntry(**d) for d in data]
+                send_fn(entries)
+                os.remove(filepath)
+                logger.info(f"离线缓存已重传: {fn} ({len(entries)} 条)")
+            except Exception as e:
+                logger.error(f"离线缓存重传失败: {e}")
+                return
+
+    def pending_count(self) -> int:
+        return len([f for f in os.listdir(self.dir) if f.startswith("offline-")])
+
+    def _cleanup(self):
+        files = sorted([os.path.join(self.dir, f) for f in os.listdir(self.dir) if f.startswith("offline-")],
+                       key=lambda x: os.path.getmtime(x))
+        total = sum(os.path.getsize(f) for f in files if os.path.exists(f))
+        for f in files:
+            if total <= self.max_size: break
+            if os.path.exists(f):
+                total -= os.path.getsize(f)
+                os.remove(f)

logs_sdk/types.py

@@ -0,0 +1,120 @@
+"""SDK 核心类型定义 — 与 Go/Node.js SDK 完全对齐"""
+from dataclasses import dataclass, field, asdict
+from typing import Optional, Any
+import json, uuid, time, socket, os, re
+
+@dataclass
+class LogConfig:
+    endpoint: str
+    api_key: str
+    api_secret: str
+    project_slug: str
+    environment: str = "production"
+    service_name: str = ""
+    buffer_size: int = 1000
+    flush_interval: int = 5
+    max_retries: int = 3
+    max_body_size: int = 4096
+    max_stack_size: int = 8192
+
+@dataclass
+class LogEntry:
+    uuid: str = ""
+    uid: int = 0
+    timestamp: str = ""
+    duration_ms: int = 0
+    project_slug: str = ""
+    environment: str = ""
+    service_name: str = ""
+    host: str = ""
+    process_id: str = ""
+    method: str = ""
+    scheme: str = ""
+    full_url: str = ""
+    host_header: str = ""
+    path: str = ""
+    query_string: str = ""
+    origin: str = ""
+    request_headers: str = "{}"
+    request_body: str = ""
+    request_body_size: int = 0
+    content_type: str = ""
+    status_code: int = 0
+    response_headers: str = "{}"
+    response_body: str = ""
+    response_body_size: int = 0
+    client_ip: str = ""
+    client_ip_chain: str = ""
+    client_type: str = "other"
+    client_port: int = 0
+    client_country: str = ""
+    client_province: str = ""
+    client_city: str = ""
+    client_isp: str = ""
+    user_agent: str = ""
+    device_type: str = ""
+    browser: str = ""
+    browser_version: str = ""
+    os_name: str = ""
+    os_version: str = ""
+    tls_version: str = ""
+    tls_cipher: str = ""
+    proto: str = ""
+    api_version: str = ""
+    referer: str = ""
+    upstream_status: int = 0
+    latency_breakdown: str = "{}"
+    request_id: str = ""
+    trace_id: str = ""
+    span_id: str = ""
+    parent_span_id: str = ""
+    user_id: str = ""
+    session_id: str = ""
+    is_error: bool = False
+    error_message: str = ""
+    error_type: str = ""
+    error_stack: str = ""
+    panic_location: str = ""
+    tags: dict = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        d = asdict(self)
+        d["tags"] = json.dumps(self.tags) if self.tags else "{}"
+        return d
+
+def new_uuid() -> str:
+    """生成 UUID v7，32 位十六进制无连字符"""
+    return uuid.uuid4().hex  # Python uuid4 无原生 v7
+
+def detect_client_type(ua: str, headers: dict) -> str:
+    """根据 User-Agent 和请求头识别客户端类型"""
+    ct = headers.get("x-client-type", "")
+    if ct: return ct
+    ua_lower = ua.lower()
+    if "micromessenger" in ua_lower or "miniprogram" in ua_lower: return "miniprogram"
+    if headers.get("x-caller-service"): return "server"
+    ref = headers.get("referer", "") or headers.get("origin", "")
+    if ref and any(b in ua_lower for b in ("mozilla", "chrome", "safari", "firefox")): return "web"
+    return "other"
+
+def detect_origin(headers: dict, ua: str) -> str:
+    ct = detect_client_type(ua, headers)
+    if ct == "web": return headers.get("referer", "") or headers.get("origin", "")
+    if ct == "miniprogram": return f"miniprogram:{headers.get('x-miniprogram-appid','')}{headers.get('x-miniprogram-path','')}"
+    if ct == "app": return f"app:{headers.get('x-app-name','')}/{headers.get('x-app-version','')}/{headers.get('x-app-scene','')}"
+    if ct == "server": return f"server:{headers.get('x-caller-service','')}/{headers.get('x-caller-version','')}"
+    return "unknown"
+
+def sanitize_headers(headers: dict) -> str:
+    safe = {}
+    for k, v in headers.items():
+        v = v[0] if isinstance(v, list) else str(v) if v else ""
+        if k.lower() in ("authorization", "cookie", "set-cookie"):
+            safe[k] = v[:15] + "..." if len(v) > 20 else "***"
+        else:
+            safe[k] = v
+    return json.dumps(safe)
+
+def extract_api_version(path: str) -> str:
+    m = re.match(r"/api/(v\d+)(/|$)", path)
+    return m.group(1) if m else ""

logs_sdk-0.3.0.dist-info/METADATA

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: logs-sdk
+Version: 0.3.0
+Summary: 日志管理平台 Python SDK — FastAPI/Starlette/Flask 中间件，自动采集 HTTP 日志
+Project-URL: Homepage, https://github.com/xiaohao0725/logs-sdk-python
+Project-URL: Repository, https://github.com/xiaohao0725/logs-sdk-python
+Author: xiaohao0725
+License: UNLICENSED
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27
+Requires-Dist: uuid6>=2024
+Provides-Extra: fastapi
+Requires-Dist: fastapi; extra == 'fastapi'
+Requires-Dist: starlette; extra == 'fastapi'
+Provides-Extra: flask
+Requires-Dist: flask; extra == 'flask'
+Description-Content-Type: text/markdown
+
+# 日志管理平台 Python SDK
+
+[English Documentation](https://github.com/xiaohao0725/logs-sdk-python/blob/main/README_EN.md) | [PyPI](https://pypi.org/project/logs-sdk/)
+
+`logs-sdk` 是日志管理平台的 Python SDK，提供 FastAPI/Starlette 和 Flask 中间件，一行代码即可自动采集 HTTP 请求的完整日志，异步批量上报。
+
+## 功能特性
+
+- ✅ **一行代码接入**：`app.add_middleware(logger.fastapi_middleware)`
+- ✅ **完整采集**：60+ 字段——请求/响应头体、客户端信息、设备信息、TLS 版本
+- ✅ **自动识别**：客户端类型（Web / 小程序 / App / 服务端）、请求来源
+- ✅ **异常捕获**：HTTP 5xx + Python 异常堆栈自动采集
+- ✅ **UUID v7**：32 位十六进制无连字符
+- ✅ **敏感脱敏**：Authorization / Cookie 自动脱敏
+- ✅ **异步非阻塞**：环形缓冲区 + 后台定时刷新
+- ✅ **离线缓存**：断网本地存储，恢复自动重传
+- ✅ **优雅关闭**：`close()` 确保缓冲日志全部上报
+
+## 安装
+
+```bash
+pip install logs-sdk
+
+# 或安装 FastAPI 集成
+pip install logs-sdk[fastapi]
+```
+
+要求 Python 3.9+。
+
+## 快速开始
+
+### FastAPI / Starlette
+
+```python
+from fastapi import FastAPI
+from logs_sdk import LogSDK
+
+app = FastAPI()
+
+logger = LogSDK(
+    endpoint="https://api.logs.codexs.cn/api/v1/ingest/logs",
+    api_key="clog_pk_xxx",
+    api_secret="clog_sk_xxx",
+    project_slug="my-project",
+    environment="production",
+)
+
+# 一行代码接入
+app.add_middleware(logger.fastapi_middleware)
+
+@app.get("/api/hello")
+def hello():
+    return {"message": "hello"}
+```
+
+### Flask
+
+```python
+from flask import Flask
+from logs_sdk import LogSDK
+
+app = Flask(__name__)
+
+logger = LogSDK(
+    endpoint="https://api.logs.codexs.cn/api/v1/ingest/logs",
+    api_key="clog_pk_xxx",
+    api_secret="clog_sk_xxx",
+    project_slug="my-project",
+)
+
+# Flask 中间件
+app.wsgi_app = logger.flask_middleware
+```
+
+## 配置参数
+
+| 参数 | 类型 | 默认值 | 说明 |
+|------|------|--------|------|
+| `endpoint` | `str` | **必填** | 日志上报地址 |
+| `api_key` | `str` | **必填** | SDK 认证密钥（公钥） |
+| `api_secret` | `str` | **必填** | SDK 认证密钥（私钥） |
+| `project_slug` | `str` | **必填** | 项目短标识 |
+| `environment` | `str` | `"production"` | 运行环境 |
+| `service_name` | `str` | `""` | 微服务名称 |
+| `buffer_size` | `int` | `1000` | 缓冲区容量 |
+| `flush_interval` | `int` | `5` | 刷新间隔（秒） |
+| `max_retries` | `int` | `3` | 最大重试次数 |
+| `max_body_size` | `int` | `4096` | 请求/响应体最大采集大小 |
+
+## 采集字段一览
+
+与 Go/Node.js/Java SDK 完全对齐，详见 [LogEntry 类型定义](./src/logs_sdk/types.py)。
+
+## 架构设计
+
+```
+HTTP 请求进入
+  │
+  ├─ ① FastAPIMiddleware.dispatch()
+  │     ├─ 生成 UUID v7
+  │     ├─ 读取请求体
+  │     └─ 记录开始时间
+  │
+  ├─ ② await call_next(request)  # 业务处理
+  │
+  ├─ ③ 构建 LogEntry（60+ 字段）
+  │
+  ├─ ④ buffer.push(entry)  # 非阻塞
+  │
+  └─ ⑤ 后台定时刷新 → POST → 重试 → 离线缓存
+```
+
+## 离线缓存
+
+断网时自动缓存到 `$TMPDIR/logs-sdk-offline/`，恢复后自动重传。
+
+## 版本历史
+
+| 版本 | 日期 | 变更 |
+|------|------|------|
+| v0.3.0 | 2026-06-21 | 初始版本：FastAPI/Flask 中间件、异步缓冲、重试、离线缓存 |
+
+## License
+
+UNLICENSED — 内部使用

logs_sdk-0.3.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+logs_sdk/__init__.py,sha256=kWcOhv8M3uuWu7BSPixt-_lFxTSsZ3SAK_vSamzCDQs,549
+logs_sdk/buffer.py,sha256=hMXa8dtxAwKrwjKO5IQKRrkseg89qGhR4T12oEuXSWo,1274
+logs_sdk/client.py,sha256=izvv2zFHW005KnDS7fjkjD4iyRtcN30wrJTliY7OEII,3639
+logs_sdk/middleware.py,sha256=McY4j5F0Mqia_2bcthLhy8cg6gvmoNIG5Fcc-IY30f4,5983
+logs_sdk/offline.py,sha256=zU8XADs6iZflSqBD-oZfPxnQfzRp6NhbEaZDFJNRGqo,2425
+logs_sdk/types.py,sha256=XQE2v_i5euMUy0Or-ZoCeuCJcseF7mHN4zpFY1yPp0I,3864
+logs_sdk-0.3.0.dist-info/METADATA,sha256=9ef-qqwp2TZWoCvkdGvPbfFTfDGYS7uPavFl252dvqg,4522
+logs_sdk-0.3.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+logs_sdk-0.3.0.dist-info/RECORD,,

logs_sdk-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any