tigrcorn-observability 0.3.16.dev5__py3-none-any.whl

tigrcorn_observability/__init__.py

@@ -0,0 +1 @@
+"""Logging, metrics, tracing helpers."""

tigrcorn_observability/events.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class Event:
+    name: str
+    attrs: dict[str, object]
+
+
+DOS_WARNING_EVENT = "tigrcorn.dos.warning"
+
+
+def dos_warning(
+    *,
+    surface: str,
+    reason: str,
+    action: str,
+    resource: str | None = None,
+    limit: int | float | None = None,
+    observed: int | float | None = None,
+) -> Event:
+    attrs: dict[str, object] = {
+        "surface": surface,
+        "reason": reason,
+        "action": action,
+    }
+    if resource is not None:
+        attrs["resource"] = resource
+    if limit is not None:
+        attrs["limit"] = limit
+    if observed is not None:
+        attrs["observed"] = observed
+    return Event(DOS_WARNING_EVENT, attrs)

tigrcorn_observability/logging.py

@@ -0,0 +1,341 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+import logging
+import logging.config
+import socket
+from logging import Logger
+from pathlib import Path
+from typing import Any, Mapping
+
+from tigrcorn_config.files import ConfigFileError, load_config_source
+
+
+class LoggingConfigError(RuntimeError):
+    pass
+
+
+_ALLOWED_PROFILE_KEYS = {
+    'level',
+    'structured',
+    'access_log',
+    'access_log_file',
+    'access_log_format',
+    'error_log_file',
+    'format',
+    'stream',
+    'syslog_app_name',
+    'syslog_enterprise_id',
+    'syslog_msgid',
+    'syslog_procid',
+    'use_colors',
+}
+
+
+@dataclass(slots=True)
+class ResolvedLoggingConfig:
+    level: str = 'info'
+    structured: bool = False
+    access_log: bool = True
+    access_log_file: str | None = None
+    access_log_format: str | None = None
+    error_log_file: str | None = None
+    format: str = 'default'
+    stream: bool = True
+    syslog_app_name: str = 'tigrcorn'
+    syslog_enterprise_id: int = 32473
+    syslog_msgid: str = '-'
+    syslog_procid: str = '-'
+    use_colors: bool | None = None
+    log_config: str | None = None
+    dict_config: dict[str, Any] | None = None
+    explicit_fields: tuple[str, ...] = ()
+
+
+class JSONFormatter(logging.Formatter):
+    def format(self, record: logging.LogRecord) -> str:
+        payload: dict[str, Any] = {
+            'timestamp': self.formatTime(record, self.datefmt),
+            'level': record.levelname,
+            'logger': record.name,
+            'message': record.getMessage(),
+        }
+        for key in ('event', 'peer', 'method', 'path', 'proto', 'status', 'result', 'trace_id', 'span_id'):
+            value = getattr(record, key, None)
+            if value is not None:
+                payload[key] = value
+        return json.dumps(payload, sort_keys=True)
+
+
+class ColorFormatter(logging.Formatter):
+    _COLORS = {
+        logging.DEBUG: '\x1b[36m',
+        logging.INFO: '\x1b[32m',
+        logging.WARNING: '\x1b[33m',
+        logging.ERROR: '\x1b[31m',
+        logging.CRITICAL: '\x1b[35m',
+    }
+    _RESET = '\x1b[0m'
+
+    def format(self, record: logging.LogRecord) -> str:
+        message = super().format(record)
+        color = self._COLORS.get(record.levelno)
+        if not color:
+            return message
+        return f'{color}{message}{self._RESET}'
+
+
+class RFC5424Formatter(logging.Formatter):
+    _SEVERITY = {
+        logging.DEBUG: 7,
+        logging.INFO: 6,
+        logging.WARNING: 4,
+        logging.ERROR: 3,
+        logging.CRITICAL: 2,
+    }
+
+    def __init__(
+        self,
+        *,
+        app_name: str = 'tigrcorn',
+        procid: str = '-',
+        msgid: str = '-',
+        enterprise_id: int = 32473,
+    ) -> None:
+        super().__init__()
+        self.app_name = app_name or '-'
+        self.procid = procid or '-'
+        self.msgid = msgid or '-'
+        self.enterprise_id = enterprise_id
+        self.hostname = socket.gethostname() or '-'
+
+    def format(self, record: logging.LogRecord) -> str:
+        timestamp = self.formatTime(record, '%Y-%m-%dT%H:%M:%S%z')
+        if timestamp.endswith('+0000'):
+            timestamp = timestamp[:-5] + 'Z'
+        priority = 8 + self._SEVERITY.get(record.levelno, 6)
+        structured_data = self._structured_data(record)
+        return (
+            f'<{priority}>1 {timestamp} {self._nil_safe(self.hostname)} '
+            f'{self._nil_safe(self.app_name)} {self._nil_safe(self.procid)} '
+            f'{self._nil_safe(self.msgid)} {structured_data} {record.getMessage()}'
+        )
+
+    def _structured_data(self, record: logging.LogRecord) -> str:
+        pairs: list[str] = []
+        for key in ('event', 'peer', 'method', 'path', 'proto', 'status', 'result', 'trace_id', 'span_id'):
+            value = getattr(record, key, None)
+            if value is not None:
+                pairs.append(f'{key}="{self._escape_param(str(value))}"')
+        if not pairs:
+            return '-'
+        return f'[tigrcorn@{self.enterprise_id} {" ".join(pairs)}]'
+
+    @staticmethod
+    def _escape_param(value: str) -> str:
+        return value.replace('\\', '\\\\').replace('"', '\\"').replace(']', '\\]')
+
+    @staticmethod
+    def _nil_safe(value: str) -> str:
+        cleaned = str(value).strip()
+        return cleaned if cleaned else '-'
+
+
+class CloseAfterEmitFileHandler(logging.Handler):
+    terminator = '\n'
+
+    def __init__(self, path: str) -> None:
+        super().__init__()
+        self.baseFilename = str(Path(path))
+        Path(path).parent.mkdir(parents=True, exist_ok=True)
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            message = self.format(record)
+            with open(self.baseFilename, 'a', encoding='utf-8') as stream:
+                stream.write(message + self.terminator)
+        except Exception:
+            self.handleError(record)
+
+
+class AccessLogger:
+    def __init__(self, logger: Logger, *, enabled: bool = True, fmt: str | None = None) -> None:
+        self.logger = logger
+        self.enabled = enabled
+        self.fmt = fmt or '{peer} "{method} {path} {proto}" {status}'
+
+    def _peer(self, client: tuple[str, int] | None) -> str:
+        return f"{client[0]}:{client[1]}" if client else '-'
+
+    def log_http(self, client: tuple[str, int] | None, method: str, path: str, status: int, proto: str) -> None:
+        if not self.enabled:
+            return
+        peer = self._peer(client)
+        message = self.fmt.format(peer=peer, method=method, path=path, status=status, proto=proto)
+        self.logger.info(message, extra={'event': 'access.http', 'peer': peer, 'method': method, 'path': path, 'status': status, 'proto': proto})
+
+    def log_ws(self, client: tuple[str, int] | None, path: str, result: str) -> None:
+        if not self.enabled:
+            return
+        peer = self._peer(client)
+        message = f'{peer} "WEBSOCKET {path}" {result}'
+        self.logger.info(message, extra={'event': 'access.websocket', 'peer': peer, 'path': path, 'result': result})
+
+
+def _coerce_level(level: str) -> int:
+    return getattr(logging, str(level).upper(), logging.INFO)
+
+
+def _file_handler(path: str, formatter: logging.Formatter) -> logging.Handler:
+    handler = CloseAfterEmitFileHandler(path)
+    handler.setFormatter(formatter)
+    return handler
+
+
+def _coerce_profile_bool(name: str, value: Any) -> bool:
+    if isinstance(value, bool):
+        return value
+    raise LoggingConfigError(f'logging profile {name!r} must be a boolean')
+
+
+def load_logging_profile(path: str | Path) -> dict[str, Any]:
+    try:
+        payload = load_config_source(path)
+    except ConfigFileError as exc:
+        raise LoggingConfigError(str(exc)) from exc
+    if 'logging' in payload and isinstance(payload['logging'], Mapping):
+        payload = dict(payload['logging'])
+    if not isinstance(payload, Mapping):
+        raise LoggingConfigError('log_config must resolve to a mapping or a top-level logging mapping')
+    if 'version' in payload:
+        return {'dict_config': dict(payload)}
+    unknown = sorted(set(payload) - _ALLOWED_PROFILE_KEYS)
+    if unknown:
+        raise LoggingConfigError(f'log_config contains unsupported keys: {unknown}')
+    result: dict[str, Any] = {}
+    for key, value in payload.items():
+        if key in {'structured', 'access_log', 'stream', 'use_colors'}:
+            result[key] = _coerce_profile_bool(key, value)
+        elif key in {
+            'level',
+            'access_log_file',
+            'access_log_format',
+            'error_log_file',
+            'format',
+            'syslog_app_name',
+            'syslog_procid',
+            'syslog_msgid',
+        }:
+            if value is not None and not isinstance(value, str):
+                raise LoggingConfigError(f'logging profile {key!r} must be a string or null')
+            result[key] = value
+        elif key == 'syslog_enterprise_id':
+            if not isinstance(value, int) or value <= 0:
+                raise LoggingConfigError("logging profile 'syslog_enterprise_id' must be a positive integer")
+            result[key] = value
+    if result.get('format') not in {None, 'default', 'json', 'rfc5424'}:
+        raise LoggingConfigError("logging profile 'format' must be one of default, json, or rfc5424")
+    return result
+
+
+def resolve_logging_config(level: str = 'info', *, config: Any | None = None) -> ResolvedLoggingConfig:
+    resolved = ResolvedLoggingConfig(level=level)
+    if config is None:
+        return resolved
+
+    explicit_fields = tuple(sorted(set(getattr(config, 'explicit_fields', []) or ())))
+    log_config_path = getattr(config, 'log_config', None)
+    if log_config_path:
+        file_profile = load_logging_profile(log_config_path)
+        for key, value in file_profile.items():
+            if hasattr(resolved, key):
+                setattr(resolved, key, value)
+        resolved.log_config = str(log_config_path)
+
+    source_fields = (
+        'level',
+        'structured',
+        'access_log',
+        'access_log_file',
+        'access_log_format',
+        'error_log_file',
+        'use_colors',
+    )
+    if not log_config_path:
+        for field_name in source_fields:
+            value = getattr(config, field_name, getattr(resolved, field_name))
+            setattr(resolved, field_name, value)
+    else:
+        for field_name in explicit_fields:
+            if field_name in source_fields:
+                setattr(resolved, field_name, getattr(config, field_name, getattr(resolved, field_name)))
+
+    resolved.explicit_fields = explicit_fields
+    return resolved
+
+
+def validate_logging_contract(config: Any | None) -> None:
+    if config is None:
+        return
+    if getattr(config, 'log_config', None):
+        resolve_logging_config(getattr(config, 'level', 'info'), config=config)
+
+
+def _stream_formatter(*, resolved: ResolvedLoggingConfig, use_colors: bool) -> logging.Formatter:
+    if resolved.format == 'rfc5424':
+        return RFC5424Formatter(
+            app_name=resolved.syslog_app_name,
+            procid=resolved.syslog_procid,
+            msgid=resolved.syslog_msgid,
+            enterprise_id=resolved.syslog_enterprise_id,
+        )
+    structured = resolved.structured or resolved.format == 'json'
+    if structured:
+        return JSONFormatter()
+    if use_colors:
+        return ColorFormatter('%(asctime)s %(levelname)s %(name)s %(message)s')
+    return logging.Formatter('%(asctime)s %(levelname)s %(name)s %(message)s')
+
+
+def configure_logging(level: str = 'info', *, config: Any | None = None) -> logging.Logger:
+    resolved = resolve_logging_config(level, config=config)
+    if resolved.dict_config is not None:
+        logging.config.dictConfig(resolved.dict_config)
+        logger = logging.getLogger('tigrcorn')
+        if 'level' in resolved.explicit_fields:
+            logger.setLevel(_coerce_level(resolved.level))
+        return logger
+
+    logger = logging.getLogger('tigrcorn')
+    for handler in list(logger.handlers):
+        logger.removeHandler(handler)
+        try:
+            handler.close()
+        except Exception:
+            pass
+
+    logger.setLevel(_coerce_level(resolved.level))
+    logger.propagate = False
+
+    if resolved.stream:
+        stream_handler = logging.StreamHandler()
+        enable_colors = resolved.use_colors
+        if enable_colors is None:
+            stream = getattr(stream_handler, 'stream', None)
+            enable_colors = bool(getattr(stream, 'isatty', lambda: False)())
+        stream_handler.setFormatter(_stream_formatter(resolved=resolved, use_colors=bool(enable_colors)))
+        logger.addHandler(stream_handler)
+
+    file_formatter: logging.Formatter = _stream_formatter(resolved=resolved, use_colors=False)
+    if resolved.access_log_file:
+        logger.addHandler(_file_handler(resolved.access_log_file, file_formatter))
+    if resolved.error_log_file and resolved.error_log_file != resolved.access_log_file:
+        logger.addHandler(_file_handler(resolved.error_log_file, file_formatter))
+
+    if not logger.handlers:
+        stream_handler = logging.StreamHandler()
+        stream_handler.setFormatter(_stream_formatter(resolved=resolved, use_colors=False))
+        logger.addHandler(stream_handler)
+
+    return logger

tigrcorn_observability/metrics.py

@@ -0,0 +1,360 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import socket
+from dataclasses import dataclass, field
+from time import monotonic, time
+from typing import Any, Mapping
+from urllib.parse import urlparse
+
+STATSD_EXPORT_SCHEMA_VERSION = 'statsd-dogstatsd-v1'
+OTEL_EXPORT_SCHEMA_VERSION = 'otlp-http-json-v1'
+STATSD_EXPORT_MODES = ('statsd', 'dogstatsd')
+
+@dataclass(slots=True)
+class Metrics:
+    started_at: float = field(default_factory=monotonic)
+    connections_opened: int = 0
+    connections_closed: int = 0
+    active_connections: int = 0
+    requests_served: int = 0
+    requests_failed: int = 0
+    websocket_connections: int = 0
+    websocket_connections_closed: int = 0
+    active_websocket_connections: int = 0
+    scheduler_tasks_spawned: int = 0
+    scheduler_tasks_rejected: int = 0
+    scheduler_rejections: int = 0
+    streams_opened: int = 0
+    websocket_pings_sent: int = 0
+    websocket_ping_timeouts: int = 0
+    protocol_errors: int = 0
+    bytes_received: int = 0
+    bytes_sent: int = 0
+    quic_datagrams_received: int = 0
+    quic_datagrams_sent: int = 0
+    quic_sessions_opened: int = 0
+    quic_sessions_closed: int = 0
+    active_quic_sessions: int = 0
+    tls_handshakes_completed: int = 0
+    quic_retry_sent: int = 0
+    quic_early_data_attempted: int = 0
+    quic_early_data_accepted: int = 0
+    quic_early_data_rejected: int = 0
+    quic_path_challenges: int = 0
+    quic_path_responses: int = 0
+    quic_path_migrations: int = 0
+    quic_packets_lost: int = 0
+    quic_pto_expirations: int = 0
+    http3_requests_served: int = 0
+    http3_stream_resets: int = 0
+    http3_goaway_received: int = 0
+    http3_qpack_encoder_streams: int = 0
+    http3_qpack_decoder_streams: int = 0
+
+    def connection_opened(self) -> None:
+        self.connections_opened += 1
+        self.active_connections += 1
+
+    def connection_closed(self) -> None:
+        self.connections_closed += 1
+        self.active_connections = max(0, self.active_connections - 1)
+
+    def websocket_opened(self) -> None:
+        self.websocket_connections += 1
+        self.active_websocket_connections += 1
+
+    def websocket_closed(self) -> None:
+        self.websocket_connections_closed += 1
+        self.active_websocket_connections = max(0, self.active_websocket_connections - 1)
+
+    def scheduler_task_spawned(self) -> None:
+        self.scheduler_tasks_spawned += 1
+
+    def scheduler_task_rejected(self) -> None:
+        self.scheduler_tasks_rejected += 1
+        self.scheduler_rejections += 1
+
+    def websocket_ping_sent(self) -> None:
+        self.websocket_pings_sent += 1
+
+    def websocket_ping_timeout(self) -> None:
+        self.websocket_ping_timeouts += 1
+
+    def quic_session_opened(self) -> None:
+        self.quic_sessions_opened += 1
+        self.active_quic_sessions += 1
+
+    def quic_session_closed(self) -> None:
+        self.quic_sessions_closed += 1
+        self.active_quic_sessions = max(0, self.active_quic_sessions - 1)
+
+    def quic_datagram_received(self, length: int = 0) -> None:
+        self.quic_datagrams_received += 1
+        if length > 0:
+            self.bytes_received += int(length)
+
+    def quic_datagram_sent(self, length: int = 0) -> None:
+        self.quic_datagrams_sent += 1
+        if length > 0:
+            self.bytes_sent += int(length)
+
+    def tls_handshake_completed(self) -> None:
+        self.tls_handshakes_completed += 1
+
+    def quic_retry_emitted(self) -> None:
+        self.quic_retry_sent += 1
+
+    def quic_early_data_observed(self, *, accepted: bool) -> None:
+        self.quic_early_data_attempted += 1
+        if accepted:
+            self.quic_early_data_accepted += 1
+        else:
+            self.quic_early_data_rejected += 1
+
+    def quic_path_challenge_observed(self) -> None:
+        self.quic_path_challenges += 1
+
+    def quic_path_response_observed(self) -> None:
+        self.quic_path_responses += 1
+
+    def quic_path_migrated(self) -> None:
+        self.quic_path_migrations += 1
+
+    def quic_packets_lost_observed(self, count: int) -> None:
+        self.quic_packets_lost += max(0, int(count))
+
+    def quic_pto_expired(self) -> None:
+        self.quic_pto_expirations += 1
+
+    def http3_request_served(self) -> None:
+        self.http3_requests_served += 1
+
+    def http3_stream_reset(self) -> None:
+        self.http3_stream_resets += 1
+
+    def http3_goaway_observed(self) -> None:
+        self.http3_goaway_received += 1
+
+    def http3_qpack_encoder_stream_opened(self) -> None:
+        self.http3_qpack_encoder_streams += 1
+
+    def http3_qpack_decoder_stream_opened(self) -> None:
+        self.http3_qpack_decoder_streams += 1
+
+    @property
+    def uptime_seconds(self) -> float:
+        return max(0.0, monotonic() - self.started_at)
+
+    def snapshot(self) -> dict[str, Any]:
+        return {
+            'uptime_seconds': round(self.uptime_seconds, 6),
+            'connections_opened': self.connections_opened,
+            'connections_closed': self.connections_closed,
+            'active_connections': self.active_connections,
+            'requests_served': self.requests_served,
+            'requests_failed': self.requests_failed,
+            'websocket_connections': self.websocket_connections,
+            'websocket_connections_closed': self.websocket_connections_closed,
+            'active_websocket_connections': self.active_websocket_connections,
+            'scheduler_tasks_spawned': self.scheduler_tasks_spawned,
+            'scheduler_tasks_rejected': self.scheduler_tasks_rejected,
+            'scheduler_rejections': self.scheduler_rejections,
+            'streams_opened': self.streams_opened,
+            'websocket_pings_sent': self.websocket_pings_sent,
+            'websocket_ping_timeouts': self.websocket_ping_timeouts,
+            'protocol_errors': self.protocol_errors,
+            'bytes_received': self.bytes_received,
+            'bytes_sent': self.bytes_sent,
+            'quic_datagrams_received': self.quic_datagrams_received,
+            'quic_datagrams_sent': self.quic_datagrams_sent,
+            'quic_sessions_opened': self.quic_sessions_opened,
+            'quic_sessions_closed': self.quic_sessions_closed,
+            'active_quic_sessions': self.active_quic_sessions,
+            'tls_handshakes_completed': self.tls_handshakes_completed,
+            'quic_retry_sent': self.quic_retry_sent,
+            'quic_early_data_attempted': self.quic_early_data_attempted,
+            'quic_early_data_accepted': self.quic_early_data_accepted,
+            'quic_early_data_rejected': self.quic_early_data_rejected,
+            'quic_path_challenges': self.quic_path_challenges,
+            'quic_path_responses': self.quic_path_responses,
+            'quic_path_migrations': self.quic_path_migrations,
+            'quic_packets_lost': self.quic_packets_lost,
+            'quic_pto_expirations': self.quic_pto_expirations,
+            'http3_requests_served': self.http3_requests_served,
+            'http3_stream_resets': self.http3_stream_resets,
+            'http3_goaway_received': self.http3_goaway_received,
+            'http3_qpack_encoder_streams': self.http3_qpack_encoder_streams,
+            'http3_qpack_decoder_streams': self.http3_qpack_decoder_streams,
+        }
+
+    def render_prometheus(self, *, prefix: str = 'tigrcorn') -> str:
+        snapshot = self.snapshot()
+        lines = []
+        for key, value in snapshot.items():
+            metric_name = f"{prefix}_{key}"
+            lines.append(f"# TYPE {metric_name} gauge")
+            lines.append(f"{metric_name} {value}")
+        return '\n'.join(lines) + '\n'
+
+    def render_statsd(self, *, prefix: str = 'tigrcorn', previous: Mapping[str, Any] | None = None) -> str:
+        return '\n'.join(iter_statsd_lines(self.snapshot(), previous=previous, prefix=prefix))
+
+
+def _is_gauge_metric(name: str) -> bool:
+    return name.startswith('active_') or name == 'uptime_seconds'
+
+
+def iter_statsd_lines(snapshot: Mapping[str, Any], *, previous: Mapping[str, Any] | None = None, prefix: str = 'tigrcorn') -> list[str]:
+    lines: list[str] = []
+    previous = previous or {}
+    for key, raw_value in snapshot.items():
+        metric_name = f'{prefix}.{key}'
+        if _is_gauge_metric(key):
+            lines.append(f'{metric_name}:{raw_value}|g')
+            continue
+        current = float(raw_value)
+        baseline = float(previous.get(key, 0))
+        delta = current - baseline
+        if delta < 0:
+            delta = current
+        lines.append(f'{metric_name}:{delta}|c')
+    return lines
+
+
+def parse_statsd_target(target: str) -> tuple[str, int, str]:
+    target = str(target).strip()
+    if not target:
+        raise ValueError('statsd_host cannot be empty')
+    mode = 'statsd'
+    if '://' in target:
+        parsed = urlparse(target)
+        if parsed.scheme not in STATSD_EXPORT_MODES:
+            raise ValueError('statsd_host scheme must be statsd:// or dogstatsd://')
+        if not parsed.hostname or parsed.port is None:
+            raise ValueError('statsd_host URL must include host and port')
+        host = parsed.hostname
+        port_value = int(parsed.port)
+        mode = parsed.scheme
+        if port_value <= 0 or port_value > 65535:
+            raise ValueError('statsd_host port must be between 1 and 65535')
+        return host, port_value, mode
+    if target.startswith('[') and ']:' in target:
+        host, port = target.rsplit(':', 1)
+        host = host[1:-1]
+    elif ':' in target:
+        host, port = target.rsplit(':', 1)
+    else:
+        raise ValueError('statsd_host must be host:port')
+    port_value = int(port)
+    if port_value <= 0 or port_value > 65535:
+        raise ValueError('statsd_host port must be between 1 and 65535')
+    if not host:
+        raise ValueError('statsd_host host cannot be empty')
+    return host, port_value, mode
+
+
+def parse_statsd_host(target: str) -> tuple[str, int]:
+    host, port, _mode = parse_statsd_target(target)
+    return host, port
+
+
+class StatsdExporter:
+    def __init__(self, target: str, *, prefix: str = 'tigrcorn', interval: float = 1.0, logger: logging.Logger | None = None) -> None:
+        self.host, self.port, self.mode = parse_statsd_target(target)
+        self.prefix = prefix
+        self.interval = max(0.1, float(interval))
+        self.logger = logger
+        self._task: asyncio.Task[None] | None = None
+        self._socket: socket.socket | None = None
+        self._sockaddr: tuple[Any, ...] | None = None
+        self._last_snapshot: dict[str, Any] | None = None
+        self.sent_packets = 0
+        self.send_failures = 0
+        self.last_payload: str | None = None
+        self.last_error: str | None = None
+
+    def _ensure_socket(self) -> socket.socket:
+        if self._socket is not None:
+            return self._socket
+        infos = socket.getaddrinfo(self.host, self.port, type=socket.SOCK_DGRAM)
+        family, socktype, proto, _canon, sockaddr = infos[0]
+        sock = socket.socket(family, socktype, proto)
+        sock.setblocking(False)
+        self._socket = sock
+        self._sockaddr = sockaddr
+        return sock
+
+    async def start(self, metrics: Metrics) -> None:
+        if self._task is not None:
+            return
+        await self.export_now(metrics)
+        self._task = asyncio.create_task(self._run(metrics), name='tigrcorn-statsd-exporter')
+
+    async def _run(self, metrics: Metrics) -> None:
+        try:
+            while True:
+                await asyncio.sleep(self.interval)
+                await self.export_now(metrics)
+        except asyncio.CancelledError:
+            raise
+
+    async def export_now(self, metrics: Metrics) -> None:
+        snapshot = metrics.snapshot()
+        payload = '\n'.join(iter_statsd_lines(snapshot, previous=self._last_snapshot, prefix=self.prefix))
+        self._last_snapshot = dict(snapshot)
+        self.last_payload = payload
+        if not payload:
+            return
+        try:
+            sock = self._ensure_socket()
+            assert self._sockaddr is not None
+            await asyncio.get_running_loop().sock_sendto(sock, payload.encode('utf-8'), self._sockaddr)
+            self.sent_packets += 1
+        except Exception as exc:  # pragma: no cover - bounded failure path exercised in tests
+            self.send_failures += 1
+            self.last_error = str(exc)
+            if self.logger is not None:
+                self.logger.warning('statsd exporter send failed: %s', exc)
+
+    async def stop(self, metrics: Metrics | None = None) -> None:
+        if metrics is not None:
+            await self.export_now(metrics)
+        if self._task is not None:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+            self._task = None
+        if self._socket is not None:
+            try:
+                self._socket.close()
+            finally:
+                self._socket = None
+                self._sockaddr = None
+
+
+def otel_metric_payload(snapshot: Mapping[str, Any], *, prefix: str = 'tigrcorn') -> list[dict[str, Any]]:
+    now_nanos = str(int(time() * 1_000_000_000))
+    metrics_payload: list[dict[str, Any]] = []
+    for key, value in snapshot.items():
+        name = f'{prefix}.{key}'
+        if _is_gauge_metric(key):
+            metrics_payload.append({
+                'name': name,
+                'gauge': {
+                    'dataPoints': [{'timeUnixNano': now_nanos, 'asDouble': float(value)}],
+                },
+            })
+        else:
+            metrics_payload.append({
+                'name': name,
+                'sum': {
+                    'aggregationTemporality': 2,
+                    'isMonotonic': True,
+                    'dataPoints': [{'timeUnixNano': now_nanos, 'asInt': int(value)}],
+                },
+            })
+    return metrics_payload

tigrcorn_observability/py.typed

@@ -0,0 +1 @@
+

tigrcorn_observability/tracing.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import random
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from contextlib import contextmanager
+from contextvars import ContextVar
+from dataclasses import asdict, dataclass
+from typing import Any, Iterator
+from uuid import uuid4
+
+from tigrcorn_observability.metrics import Metrics, OTEL_EXPORT_SCHEMA_VERSION, otel_metric_payload
+
+_current_trace_id: ContextVar[str | None] = ContextVar('tigrcorn_trace_id', default=None)
+_current_span_id: ContextVar[str | None] = ContextVar('tigrcorn_span_id', default=None)
+
+
+@dataclass(slots=True)
+class SpanRecord:
+    name: str
+    trace_id: str
+    span_id: str
+    start_time: float
+    end_time: float | None = None
+    attrs: dict[str, Any] | None = None
+
+
+@contextmanager
+def span(name: str, *, attrs: dict[str, Any] | None = None, sample_rate: float = 1.0, sink: callable | None = None) -> Iterator[SpanRecord | None]:
+    if sample_rate <= 0 or random.random() > sample_rate:
+        yield None
+        return
+    trace_id = _current_trace_id.get() or uuid4().hex
+    span_id = uuid4().hex[:16]
+    token_trace = _current_trace_id.set(trace_id)
+    token_span = _current_span_id.set(span_id)
+    record = SpanRecord(name=name, trace_id=trace_id, span_id=span_id, start_time=time.time(), attrs=dict(attrs or {}))
+    try:
+        yield record
+    finally:
+        record.end_time = time.time()
+        if sink is not None:
+            sink(record)
+        _current_span_id.reset(token_span)
+        _current_trace_id.reset(token_trace)
+
+
+def parse_otel_endpoint(endpoint: str) -> str:
+    parsed = urllib.parse.urlparse(str(endpoint).strip())
+    if parsed.scheme not in {'http', 'https'}:
+        raise ValueError('otel_endpoint must use http:// or https://')
+    if not parsed.netloc:
+        raise ValueError('otel_endpoint must include a network location')
+    return urllib.parse.urlunparse(parsed)
+
+
+class OtelExporter:
+    def __init__(self, endpoint: str, *, service_name: str = 'tigrcorn', interval: float = 1.0, logger: logging.Logger | None = None, timeout: float = 2.0) -> None:
+        self.endpoint = parse_otel_endpoint(endpoint)
+        self.service_name = service_name
+        self.interval = max(0.1, float(interval))
+        self.logger = logger
+        self.timeout = float(timeout)
+        self._task: asyncio.Task[None] | None = None
+        self._span_buffer: list[dict[str, Any]] = []
+        self.buffer_limit = 256
+        self.sent_batches = 0
+        self.send_failures = 0
+        self.last_error: str | None = None
+        self.last_payload: dict[str, Any] | None = None
+
+    def record_span(self, record: SpanRecord) -> None:
+        payload = {
+            'traceId': record.trace_id,
+            'spanId': record.span_id,
+            'name': record.name,
+            'startTimeUnixNano': str(int(record.start_time * 1_000_000_000)),
+            'endTimeUnixNano': str(int((record.end_time or record.start_time) * 1_000_000_000)),
+            'attributes': [
+                {
+                    'key': key,
+                    'value': {'stringValue': str(value)},
+                }
+                for key, value in sorted((record.attrs or {}).items())
+            ],
+        }
+        self._span_buffer.append(payload)
+        if len(self._span_buffer) > self.buffer_limit:
+            self._span_buffer = self._span_buffer[-self.buffer_limit :]
+
+    def _resource(self) -> dict[str, Any]:
+        return {
+            'attributes': [
+                {'key': 'service.name', 'value': {'stringValue': self.service_name}},
+            ]
+        }
+
+    def _build_payload(self, metrics: Metrics) -> dict[str, Any]:
+        snapshot = metrics.snapshot()
+        spans = list(self._span_buffer)
+        return {
+            'resourceMetrics': [
+                {
+                    'resource': self._resource(),
+                    'scopeMetrics': [
+                        {
+                            'scope': {'name': 'tigrcorn', 'version': OTEL_EXPORT_SCHEMA_VERSION},
+                            'metrics': otel_metric_payload(snapshot),
+                        }
+                    ],
+                }
+            ],
+            'resourceSpans': [
+                {
+                    'resource': self._resource(),
+                    'scopeSpans': [
+                        {
+                            'scope': {'name': 'tigrcorn', 'version': OTEL_EXPORT_SCHEMA_VERSION},
+                            'spans': spans,
+                        }
+                    ],
+                }
+            ],
+        }
+
+    def _post_json(self, payload: dict[str, Any]) -> None:
+        body = json.dumps(payload, sort_keys=True).encode('utf-8')
+        request = urllib.request.Request(self.endpoint, data=body, method='POST', headers={'content-type': 'application/json'})
+        with urllib.request.urlopen(request, timeout=self.timeout) as response:  # noqa: S310
+            response.read()
+
+    async def start(self, metrics: Metrics) -> None:
+        if self._task is not None:
+            return
+        await self.export_now(metrics)
+        self._task = asyncio.create_task(self._run(metrics), name='tigrcorn-otel-exporter')
+
+    async def _run(self, metrics: Metrics) -> None:
+        try:
+            while True:
+                await asyncio.sleep(self.interval)
+                await self.export_now(metrics)
+        except asyncio.CancelledError:
+            raise
+
+    async def export_now(self, metrics: Metrics) -> None:
+        payload = self._build_payload(metrics)
+        self.last_payload = payload
+        spans_before = list(self._span_buffer)
+        try:
+            await asyncio.to_thread(self._post_json, payload)
+            self.sent_batches += 1
+            self._span_buffer.clear()
+        except Exception as exc:  # pragma: no cover - bounded failure path exercised in tests
+            self.send_failures += 1
+            self.last_error = str(exc)
+            self._span_buffer = spans_before
+            if self.logger is not None:
+                self.logger.warning('otel exporter post failed: %s', exc)
+
+    async def stop(self, metrics: Metrics | None = None) -> None:
+        if metrics is not None:
+            await self.export_now(metrics)
+        if self._task is not None:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+            self._task = None
+
+
+def validate_otel_endpoint(endpoint: str | None) -> None:
+    if endpoint:
+        parse_otel_endpoint(endpoint)

tigrcorn_observability-0.3.16.dev5.dist-info/METADATA

@@ -0,0 +1,236 @@
+Metadata-Version: 2.4
+Name: tigrcorn-observability
+Version: 0.3.16.dev5
+Summary: Logging, metrics, tracing, DoS warning events, and release-evidence metadata for the Tigrcorn Python web server.
+Author-email: Jacob Stewart <jacob@swarmauri.com>
+License: Apache License
+        Version 2.0, January 2004
+        http://www.apache.org/licenses/
+        
+        TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+        1. Definitions.
+        
+           "License" shall mean the terms and conditions for use, reproduction, and
+           distribution as defined by Sections 1 through 9 of this document.
+        
+           "Licensor" shall mean the copyright owner or entity authorized by the
+           copyright owner that is granting the License.
+        
+           "Legal Entity" shall mean the union of the acting entity and all other
+           entities that control, are controlled by, or are under common control with
+           that entity. For the purposes of this definition, "control" means (i) the
+           power, direct or indirect, to cause the direction or management of such
+           entity, whether by contract or otherwise, or (ii) ownership of fifty percent
+           (50%) or more of the outstanding shares, or (iii) beneficial ownership of
+           such entity.
+        
+           "You" (or "Your") shall mean an individual or Legal Entity exercising
+           permissions granted by this License.
+        
+           "Source" form shall mean the preferred form for making modifications,
+           including but not limited to software source code, documentation source, and
+           configuration files.
+        
+           "Object" form shall mean any form resulting from mechanical transformation
+           or translation of a Source form, including but not limited to compiled object
+           code, generated documentation, and conversions to other media types.
+        
+           "Work" shall mean the work of authorship, whether in Source or Object form,
+           made available under the License, as indicated by a copyright notice that is
+           included in or attached to the work (an example is provided in the Appendix
+           below).
+        
+           "Derivative Works" shall mean any work, whether in Source or Object form,
+           that is based on (or derived from) the Work and for which the editorial
+           revisions, annotations, elaborations, or other modifications represent, as a
+           whole, an original work of authorship. For the purposes of this License,
+           Derivative Works shall not include works that remain separable from, or
+           merely link (or bind by name) to the interfaces of, the Work and Derivative
+           Works thereof.
+        
+           "Contribution" shall mean any work of authorship, including the original
+           version of the Work and any modifications or additions to that Work or
+           Derivative Works thereof, that is intentionally submitted to Licensor for
+           inclusion in the Work by the copyright owner or by an individual or Legal
+           Entity authorized to submit on behalf of the copyright owner. For the
+           purposes of this definition, "submitted" means any form of electronic,
+           verbal, or written communication sent to the Licensor or its representatives,
+           including but not limited to communication on electronic mailing lists,
+           source code control systems, and issue tracking systems that are managed by,
+           or on behalf of, the Licensor for the purpose of discussing and improving the
+           Work, but excluding communication that is conspicuously marked or otherwise
+           designated in writing by the copyright owner as "Not a Contribution."
+        
+           "Contributor" shall mean Licensor and any individual or Legal Entity on
+           behalf of whom a Contribution has been received by Licensor and subsequently
+           incorporated within the Work.
+        
+        2. Grant of Copyright License. Subject to the terms and conditions of this
+           License, each Contributor hereby grants to You a perpetual, worldwide,
+           non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+           reproduce, prepare Derivative Works of, publicly display, publicly perform,
+           sublicense, and distribute the Work and such Derivative Works in Source or
+           Object form.
+        
+        3. Grant of Patent License. Subject to the terms and conditions of this
+           License, each Contributor hereby grants to You a perpetual, worldwide,
+           non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this
+           section) patent license to make, have made, use, offer to sell, sell, import,
+           and otherwise transfer the Work, where such license applies only to those
+           patent claims licensable by such Contributor that are necessarily infringed by
+           their Contribution(s) alone or by combination of their Contribution(s) with
+           the Work to which such Contribution(s) was submitted. If You institute patent
+           litigation against any entity (including a cross-claim or counterclaim in a
+           lawsuit) alleging that the Work or a Contribution incorporated within the Work
+           constitutes direct or contributory patent infringement, then any patent
+           licenses granted to You under this License for that Work shall terminate as of
+           the date such litigation is filed.
+        
+        4. Redistribution. You may reproduce and distribute copies of the Work or
+           Derivative Works thereof in any medium, with or without modifications, and in
+           Source or Object form, provided that You meet the following conditions:
+        
+           (a) You must give any other recipients of the Work or Derivative Works a copy
+               of this License; and
+        
+           (b) You must cause any modified files to carry prominent notices stating that
+               You changed the files; and
+        
+           (c) You must retain, in the Source form of any Derivative Works that You
+               distribute, all copyright, patent, trademark, and attribution notices
+               from the Source form of the Work, excluding those notices that do not
+               pertain to any part of the Derivative Works; and
+        
+           (d) If the Work includes a "NOTICE" text file as part of its distribution,
+               then any Derivative Works that You distribute must include a readable copy
+               of the attribution notices contained within such NOTICE file, excluding
+               those notices that do not pertain to any part of the Derivative Works, in
+               at least one of the following places: within a NOTICE text file distributed
+               as part of the Derivative Works; within the Source form or documentation,
+               if provided along with the Derivative Works; or, within a display generated
+               by the Derivative Works, if and wherever such third-party notices normally
+               appear. The contents of the NOTICE file are for informational purposes only
+               and do not modify the License. You may add Your own attribution notices
+               within Derivative Works that You distribute, alongside or as an addendum to
+               the NOTICE text from the Work, provided that such additional attribution
+               notices cannot be construed as modifying the License.
+        
+           You may add Your own copyright statement to Your modifications and may provide
+           additional or different license terms and conditions for use, reproduction, or
+           distribution of Your modifications, or for any such Derivative Works as a
+           whole, provided Your use, reproduction, and distribution of the Work otherwise
+           complies with the conditions stated in this License.
+        
+        5. Submission of Contributions. Unless You explicitly state otherwise, any
+           Contribution intentionally submitted for inclusion in the Work by You to the
+           Licensor shall be under the terms and conditions of this License, without any
+           additional terms or conditions. Notwithstanding the above, nothing herein
+           shall supersede or modify the terms of any separate license agreement you may
+           have executed with Licensor regarding such Contributions.
+        
+        6. Trademarks. This License does not grant permission to use the trade names,
+           trademarks, service marks, or product names of the Licensor, except as
+           required for reasonable and customary use in describing the origin of the Work
+           and reproducing the content of the NOTICE file.
+        
+        7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+           writing, Licensor provides the Work (and each Contributor provides its
+           Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+           KIND, either express or implied, including, without limitation, any warranties
+           or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+           PARTICULAR PURPOSE. You are solely responsible for determining the
+           appropriateness of using or redistributing the Work and assume any risks
+           associated with Your exercise of permissions under this License.
+        
+        8. Limitation of Liability. In no event and under no legal theory, whether in
+           tort (including negligence), contract, or otherwise, unless required by
+           applicable law (such as deliberate and grossly negligent acts) or agreed to in
+           writing, shall any Contributor be liable to You for damages, including any
+           direct, indirect, special, incidental, or consequential damages of any
+           character arising as a result of this License or out of the use or inability
+           to use the Work (including but not limited to damages for loss of goodwill,
+           work stoppage, computer failure or malfunction, or any and all other
+           commercial damages or losses), even if such Contributor has been advised of
+           the possibility of such damages.
+        
+        9. Accepting Warranty or Additional Liability. While redistributing the Work or
+           Derivative Works thereof, You may choose to offer, and charge a fee for,
+           acceptance of support, warranty, indemnity, or other liability obligations
+           and/or rights consistent with this License. However, in accepting such
+           obligations, You may act only on Your own behalf and on Your sole
+           responsibility, not on behalf of any other Contributor, and only if You agree
+           to indemnify, defend, and hold each Contributor harmless for any liability
+           incurred by, or claims asserted against, such Contributor by reason of your
+           accepting any such warranty or additional liability.
+        
+        END OF TERMS AND CONDITIONS
+        
+        
+Keywords: tigrcorn,observability,logging,metrics,tracing,dos-warning,release-evidence
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tigrcorn-core==0.3.16.dev5
+Requires-Dist: tigrcorn-config==0.3.16.dev5
+Dynamic: license-file
+
+<div align="center">
+<h1>tigrcorn-observability</h1>
+
+<p><strong>Logging, metrics, tracing, DoS warning events, and release-evidence metadata for the Tigrcorn Python web server.</strong></p>
+
+<a href="https://pypi.org/project/tigrcorn-observability/"><img alt="PyPI version for tigrcorn-observability" src="https://img.shields.io/pypi/v/tigrcorn-observability?label=PyPI"></a>
+<a href="https://pypi.org/project/tigrcorn-observability/"><img alt="tigrcorn-observability package on PyPI" src="https://img.shields.io/badge/package-PyPI-blue"></a>
+<a href="LICENSE"><img alt="Apache 2.0 license" src="https://img.shields.io/badge/license-Apache%202.0-525252"></a>
+<a href="pyproject.toml"><img alt="Python 3.11 supported" src="https://img.shields.io/badge/python-3.11-3776ab"></a>
+<a href="pyproject.toml"><img alt="Python 3.12 supported" src="https://img.shields.io/badge/python-3.12-3776ab"></a>
+<a href="pyproject.toml"><img alt="Python 3.13 supported" src="https://img.shields.io/badge/python-3.13-3776ab"></a>
+<a href="src/tigrcorn_observability/py.typed"><img alt="typed package" src="https://img.shields.io/badge/typed-py.typed-2f7ed8"></a>
+<a href="https://pypi.org/project/tigrcorn-observability/"><img alt="observability role package" src="https://img.shields.io/badge/role-observability-0a7f5a"></a>
+</div>
+
+## Install
+
+~~~bash
+pip install tigrcorn-observability
+~~~
+
+Use the aggregate [tigrcorn](https://pypi.org/project/tigrcorn/) distribution when you want the full ASGI3 Python web server stack. Install <code>tigrcorn-observability</code> directly when you want only this package boundary and its declared dependencies.
+
+## What It Owns
+
+<code>tigrcorn-observability</code> owns logging, metrics, tracing, DoS warning events, and evidence metadata export surfaces. Its import package is <code>tigrcorn_observability</code>, and its declared package dependencies are: tigrcorn-core, tigrcorn-config.
+
+This package page is written for developers searching for Tigrcorn ASGI3 server components, Python web server packages, HTTP/3 and QUIC support, WebSocket and WebTransport runtime surfaces, typed package boundaries, and Apache 2.0 licensed infrastructure.
+
+## Use It When
+
+Use <code>tigrcorn-observability</code> when you need searchable Tigrcorn observability signals for runtime telemetry, protocol stalls, metrics, tracing, or release evidence. It is part of Tigrcorn's split-package architecture, so it can be installed independently while remaining linked to the rest of the Tigrcorn package family on PyPI.
+
+## Import Surface
+
+~~~python
+import tigrcorn_observability
+
+print(tigrcorn_observability.__name__)
+~~~
+
+The package exposes its supported public surface through the <code>tigrcorn_observability</code> namespace. The root [tigrcorn](https://pypi.org/project/tigrcorn/) package keeps compatibility shims for users who install the full server distribution.
+
+## Package Graph
+
+[tigrcorn](https://pypi.org/project/tigrcorn/) | [tigrcorn-core](https://pypi.org/project/tigrcorn-core/) | [tigrcorn-config](https://pypi.org/project/tigrcorn-config/) | [tigrcorn-asgi](https://pypi.org/project/tigrcorn-asgi/) | [tigrcorn-contract](https://pypi.org/project/tigrcorn-contract/) | [tigrcorn-transports](https://pypi.org/project/tigrcorn-transports/) | [tigrcorn-protocols](https://pypi.org/project/tigrcorn-protocols/) | [tigrcorn-http](https://pypi.org/project/tigrcorn-http/) | [tigrcorn-security](https://pypi.org/project/tigrcorn-security/) | [tigrcorn-runtime](https://pypi.org/project/tigrcorn-runtime/) | [tigrcorn-static](https://pypi.org/project/tigrcorn-static/) | [tigrcorn-observability](https://pypi.org/project/tigrcorn-observability/) | [tigrcorn-compat](https://pypi.org/project/tigrcorn-compat/) | [tigrcorn-certification](https://pypi.org/project/tigrcorn-certification/)

tigrcorn_observability-0.3.16.dev5.dist-info/RECORD

@@ -0,0 +1,11 @@
+tigrcorn_observability/__init__.py,sha256=uzT17-65ZfvM3GF9HaKwtpkAiw0RA6zy3-IOL9ligzQ,40
+tigrcorn_observability/events.py,sha256=AvlCLkxztUquuf7j5IPdRh0aKSKbePmpnIVQIqwf9xY,749
+tigrcorn_observability/logging.py,sha256=Yo3n0AfP_8Ldwrqerr-00FDOhngoMSXXfcNTbCw--wA,12196
+tigrcorn_observability/metrics.py,sha256=64dnNMGR7-A8O_yBQYiPj-SwkgdEibENGAVmidCY9Q4,13830
+tigrcorn_observability/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+tigrcorn_observability/tracing.py,sha256=DNwfmAr45izrMtDCQwmx961Rs2UoFda8inpOad-dbYk,6600
+tigrcorn_observability-0.3.16.dev5.dist-info/licenses/LICENSE,sha256=xhBSirl227aDQNeQ8tk2v_yiU9nbQpJ4EZp6OtATX-s,9591
+tigrcorn_observability-0.3.16.dev5.dist-info/METADATA,sha256=eVLuEtyW90UljRAXK6iRtxqZ2ImhGgfkDqSbeUR7spw,15866
+tigrcorn_observability-0.3.16.dev5.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+tigrcorn_observability-0.3.16.dev5.dist-info/top_level.txt,sha256=h4gAnmVbhRM9JHPNrpLglQZii7bWoLAo1UB5KeCNjbc,23
+tigrcorn_observability-0.3.16.dev5.dist-info/RECORD,,

tigrcorn_observability-0.3.16.dev5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tigrcorn_observability-0.3.16.dev5.dist-info/licenses/LICENSE

@@ -0,0 +1,163 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction, and
+   distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by the
+   copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all other
+   entities that control, are controlled by, or are under common control with
+   that entity. For the purposes of this definition, "control" means (i) the
+   power, direct or indirect, to cause the direction or management of such
+   entity, whether by contract or otherwise, or (ii) ownership of fifty percent
+   (50%) or more of the outstanding shares, or (iii) beneficial ownership of
+   such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity exercising
+   permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation source, and
+   configuration files.
+
+   "Object" form shall mean any form resulting from mechanical transformation
+   or translation of a Source form, including but not limited to compiled object
+   code, generated documentation, and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or Object form,
+   made available under the License, as indicated by a copyright notice that is
+   included in or attached to the work (an example is provided in the Appendix
+   below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object form,
+   that is based on (or derived from) the Work and for which the editorial
+   revisions, annotations, elaborations, or other modifications represent, as a
+   whole, an original work of authorship. For the purposes of this License,
+   Derivative Works shall not include works that remain separable from, or
+   merely link (or bind by name) to the interfaces of, the Work and Derivative
+   Works thereof.
+
+   "Contribution" shall mean any work of authorship, including the original
+   version of the Work and any modifications or additions to that Work or
+   Derivative Works thereof, that is intentionally submitted to Licensor for
+   inclusion in the Work by the copyright owner or by an individual or Legal
+   Entity authorized to submit on behalf of the copyright owner. For the
+   purposes of this definition, "submitted" means any form of electronic,
+   verbal, or written communication sent to the Licensor or its representatives,
+   including but not limited to communication on electronic mailing lists,
+   source code control systems, and issue tracking systems that are managed by,
+   or on behalf of, the Licensor for the purpose of discussing and improving the
+   Work, but excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity on
+   behalf of whom a Contribution has been received by Licensor and subsequently
+   incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this
+   License, each Contributor hereby grants to You a perpetual, worldwide,
+   non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+   reproduce, prepare Derivative Works of, publicly display, publicly perform,
+   sublicense, and distribute the Work and such Derivative Works in Source or
+   Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this
+   License, each Contributor hereby grants to You a perpetual, worldwide,
+   non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this
+   section) patent license to make, have made, use, offer to sell, sell, import,
+   and otherwise transfer the Work, where such license applies only to those
+   patent claims licensable by such Contributor that are necessarily infringed by
+   their Contribution(s) alone or by combination of their Contribution(s) with
+   the Work to which such Contribution(s) was submitted. If You institute patent
+   litigation against any entity (including a cross-claim or counterclaim in a
+   lawsuit) alleging that the Work or a Contribution incorporated within the Work
+   constitutes direct or contributory patent infringement, then any patent
+   licenses granted to You under this License for that Work shall terminate as of
+   the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or
+   Derivative Works thereof in any medium, with or without modifications, and in
+   Source or Object form, provided that You meet the following conditions:
+
+   (a) You must give any other recipients of the Work or Derivative Works a copy
+       of this License; and
+
+   (b) You must cause any modified files to carry prominent notices stating that
+       You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works that You
+       distribute, all copyright, patent, trademark, and attribution notices
+       from the Source form of the Work, excluding those notices that do not
+       pertain to any part of the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its distribution,
+       then any Derivative Works that You distribute must include a readable copy
+       of the attribution notices contained within such NOTICE file, excluding
+       those notices that do not pertain to any part of the Derivative Works, in
+       at least one of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or documentation,
+       if provided along with the Derivative Works; or, within a display generated
+       by the Derivative Works, if and wherever such third-party notices normally
+       appear. The contents of the NOTICE file are for informational purposes only
+       and do not modify the License. You may add Your own attribution notices
+       within Derivative Works that You distribute, alongside or as an addendum to
+       the NOTICE text from the Work, provided that such additional attribution
+       notices cannot be construed as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and may provide
+   additional or different license terms and conditions for use, reproduction, or
+   distribution of Your modifications, or for any such Derivative Works as a
+   whole, provided Your use, reproduction, and distribution of the Work otherwise
+   complies with the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any
+   Contribution intentionally submitted for inclusion in the Work by You to the
+   Licensor shall be under the terms and conditions of this License, without any
+   additional terms or conditions. Notwithstanding the above, nothing herein
+   shall supersede or modify the terms of any separate license agreement you may
+   have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names,
+   trademarks, service marks, or product names of the Licensor, except as
+   required for reasonable and customary use in describing the origin of the Work
+   and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+   writing, Licensor provides the Work (and each Contributor provides its
+   Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+   KIND, either express or implied, including, without limitation, any warranties
+   or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any risks
+   associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in
+   tort (including negligence), contract, or otherwise, unless required by
+   applicable law (such as deliberate and grossly negligent acts) or agreed to in
+   writing, shall any Contributor be liable to You for damages, including any
+   direct, indirect, special, incidental, or consequential damages of any
+   character arising as a result of this License or out of the use or inability
+   to use the Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all other
+   commercial damages or losses), even if such Contributor has been advised of
+   the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or
+   Derivative Works thereof, You may choose to offer, and charge a fee for,
+   acceptance of support, warranty, indemnity, or other liability obligations
+   and/or rights consistent with this License. However, in accepting such
+   obligations, You may act only on Your own behalf and on Your sole
+   responsibility, not on behalf of any other Contributor, and only if You agree
+   to indemnify, defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason of your
+   accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+

tigrcorn_observability-0.3.16.dev5.dist-info/top_level.txt

@@ -0,0 +1 @@
+tigrcorn_observability