pycommonlog 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

pycommonlog/log_types.py

@@ -49,6 +49,16 @@ class Config:
         self.environment = environment
         self.provider_config = provider_config or {}
         self.debug = debug
+        
+        # Populate provider_config with top-level fields for consistency, only if top-level is set
+        if self.provider:
+            self.provider_config["provider"] = self.provider
+        if self.token:
+            self.provider_config["token"] = self.token
+        if self.slack_token:
+            self.provider_config["slack_token"] = self.slack_token
+        if self.lark_token and (self.lark_token.app_id or self.lark_token.app_secret):
+            self.provider_config["lark_token"] = self.lark_token
 
 class Provider(ABC):
     @abstractmethod

pycommonlog/logger.py

@@ -104,15 +104,16 @@ class commonlog:
 
     def __init__(self, config):
         self.config = config
-        if config.provider == "slack":
+        provider_name = config.provider_config.get("provider", "slack")
+        if provider_name == "slack":
             self.provider = SlackProvider()
-        elif config.provider == "lark":
+        elif provider_name == "lark":
             self.provider = LarkProvider()
         else:
-            logging.warning(f"Unknown provider: {config.provider}, defaulting to Slack")
+            logging.warning(f"Unknown provider: {provider_name}, defaulting to Slack")
             self.provider = SlackProvider()
         
-        debug_log(config, f"Created logger with provider: {config.provider}, send method: {config.send_method}, debug: {config.debug}")
+        debug_log(config, f"Created logger with provider: {provider_name}, send method: {config.send_method}, debug: {config.debug}")
 
     def _resolve_channel(self, level):
         if self.config.channel_resolver:

pycommonlog/providers/__init__.py

@@ -0,0 +1,7 @@
+"""
+Providers package for commonlog
+"""
+from .slack import SlackProvider
+from .lark import LarkProvider
+
+__all__ = ["SlackProvider", "LarkProvider"]

pycommonlog/providers/lark.py

@@ -0,0 +1,279 @@
+"""
+Lark Provider for commonlog
+"""
+import requests
+import json
+import sys
+import os
+import time
+import threading
+from typing import Dict, Optional, Tuple
+
+# Add directories to path for imports
+_current_dir = os.path.dirname(os.path.abspath(__file__))
+_parent_dir = os.path.dirname(_current_dir)
+if _parent_dir not in sys.path:
+    sys.path.insert(0, _parent_dir)
+if _current_dir not in sys.path:
+    sys.path.insert(0, _current_dir)
+
+from log_types import SendMethod, Provider, debug_log
+from redis_client import get_redis_client, RedisConfigError
+from cache import get_memory_cache
+
+class LarkProvider(Provider):
+    def send_to_channel(self, level, message, attachment, config, channel):
+        original_channel = config.channel
+        config.channel = channel
+        title, formatted_message = self._format_message(message, attachment, config)
+        if config.send_method == SendMethod.WEBCLIENT:
+            self._send_lark_webclient(title, formatted_message, config)
+        elif config.send_method == SendMethod.WEBHOOK:
+            self._send_lark_webhook(title, formatted_message, config)
+        config.channel = original_channel
+
+    def cache_lark_token(self, config, app_id, app_secret, token, expire):
+        key = f"commonlog_lark_token:{app_id}:{app_secret}"
+        try:
+            client = get_redis_client(config)
+            expire_seconds = expire - 600
+            if expire_seconds <= 0:
+                expire_seconds = 60
+            client.setex(key, expire_seconds, token)
+            debug_log(config, f"Lark token cached in Redis for key: {key}")
+        except RedisConfigError:
+            # Fallback to in-memory cache
+            expire_seconds = expire - 600
+            if expire_seconds <= 0:
+                expire_seconds = 60
+            get_memory_cache().set(key, token, expire_seconds)
+            debug_log(config, f"Lark token cached in memory for key: {key}")
+
+    def get_cached_lark_token(self, config, app_id, app_secret):
+        key = f"commonlog_lark_token:{app_id}:{app_secret}"
+        try:
+            client = get_redis_client(config)
+            token = client.get(key)
+            if token:
+                debug_log(config, f"Lark token retrieved from Redis for key: {key}")
+            return token
+        except RedisConfigError:
+            # Fallback to in-memory cache
+            token = get_memory_cache().get(key)
+            if token:
+                debug_log(config, f"Lark token retrieved from memory for key: {key}")
+            return token
+
+    def cache_chat_id(self, config, channel_name, chat_id):
+        key = f"commonlog_lark_chat_id:{config.environment}:{channel_name}"
+        try:
+            client = get_redis_client(config)
+            client.set(key, chat_id)  # No expiry
+            debug_log(config, f"Lark chat ID cached in Redis for key: {key}")
+        except RedisConfigError:
+            # Fallback to in-memory cache (no expiry for chat IDs)
+            get_memory_cache().set(key, chat_id, 86400 * 30)  # 30 days expiry
+            debug_log(config, f"Lark chat ID cached in memory for key: {key}")
+
+    def get_cached_chat_id(self, config, channel_name):
+        key = f"commonlog_lark_chat_id:{config.environment}:{channel_name}"
+        try:
+            client = get_redis_client(config)
+            chat_id = client.get(key)
+            if chat_id:
+                debug_log(config, f"Lark chat ID retrieved from Redis for key: {key}")
+            return chat_id
+        except RedisConfigError:
+            # Fallback to in-memory cache
+            chat_id = get_memory_cache().get(key)
+            if chat_id:
+                debug_log(config, f"Lark chat ID retrieved from memory for key: {key}")
+            return chat_id
+
+    def get_tenant_access_token(self, config, app_id, app_secret):
+        cached = self.get_cached_lark_token(config, app_id, app_secret)
+        if cached:
+            return cached
+        url = "https://open.larksuite.com/open-apis/auth/v3/tenant_access_token/internal"
+        payload = {"app_id": app_id, "app_secret": app_secret}
+        response = requests.post(url, json=payload)
+        result = response.json()
+        if result.get("code", 1) != 0:
+            raise Exception(f"lark token error: {result.get('msg')}")
+        token = result.get("tenant_access_token")
+        expire = result.get("expire", 0)
+        self.cache_lark_token(config, app_id, app_secret, token, expire)
+        return token
+
+    def get_chat_id_from_channel_name(self, config, token, channel_name):
+        """Get chat_id from channel name using Lark API with pagination"""
+        # Try Redis cache first
+        cached = self.get_cached_chat_id(config, channel_name)
+        if cached:
+            return cached
+        
+        base_url = "https://open.larksuite.com/open-apis/im/v1/chats"
+        headers = {"Authorization": f"Bearer {token}"}
+        
+        all_chats = []
+        page_token = ""
+        has_more = True
+        
+        while has_more:
+            url = f"{base_url}?page_size=10"
+            if page_token:
+                url += f"&page_token={page_token}"
+            
+            response = requests.get(url, headers=headers)
+            if response.status_code != 200:
+                raise Exception(f"Lark chats API response: {response.status_code}")
+            
+            result = response.json()
+            
+            # Check for API error
+            if result.get("code", 1) != 0:
+                raise Exception(f"Lark API error: {result.get('msg', 'Unknown error')}")
+            
+            data = result.get("data", {})
+            items = data.get("items", [])
+            
+            # Add current page items to all chats
+            all_chats.extend(items)
+            
+            # Update pagination info
+            page_token = data.get("page_token", "")
+            has_more = data.get("has_more", False)
+        
+        # Find the chat with matching name
+        for item in all_chats:
+            if item.get("name") == channel_name:
+                chat_id = item.get("chat_id")
+                # Cache the chat_id without expiry
+                self.cache_chat_id(config, channel_name, chat_id)
+                return chat_id
+        
+        raise Exception(f"Channel '{channel_name}' not found")
+
+    def send(self, level, message, attachment, config):
+        debug_log(config, f"LarkProvider.send called with level: {level}, send method: {config.send_method}")
+        title, formatted_message = self._format_message(message, attachment, config)
+        if config.send_method == SendMethod.WEBCLIENT:
+            debug_log(config, "Using Lark webclient method")
+            self._send_lark_webclient(title, formatted_message, config)
+        elif config.send_method == SendMethod.WEBHOOK:
+            debug_log(config, "Using Lark webhook method")
+            self._send_lark_webhook(title, formatted_message, config)
+        else:
+            error_msg = f"Unknown send method for Lark: {config.send_method}"
+            debug_log(config, f"Error: {error_msg}")
+            raise ValueError(error_msg)
+
+    def _format_message(self, message, attachment, config):
+        # Extract title from service and environment
+        title = "Alert"
+        if config.service_name and config.environment:
+            title = f"{config.service_name} - {config.environment}"
+        elif config.service_name:
+            title = config.service_name
+        elif config.environment:
+            title = config.environment
+        
+        # Format message content without the header
+        formatted = message
+        if attachment and attachment.content:
+            filename = attachment.file_name or "Trace Logs"
+            formatted += f"\n\n**{filename}:**\n```\n{attachment.content}\n```"
+        if attachment and attachment.url:
+            formatted += f"\n\n**Attachment:** {attachment.url}"
+        return title, json.dumps(formatted)
+
+    def _send_lark_webclient(self, title, formatted_message, config):
+        debug_log(config, "send_lark_webclient: preparing API request")
+        token = config.provider_config.get("token", "")
+        
+        # Use lark_token if available, otherwise fall back to token parsing
+        lark_token = config.provider_config.get("lark_token")
+        if lark_token and lark_token.app_id and lark_token.app_secret:
+            debug_log(config, "send_lark_webclient: fetching tenant access token using lark_token")
+            token = self.get_tenant_access_token(config, lark_token.app_id, lark_token.app_secret)
+            debug_log(config, "send_lark_webclient: tenant access token fetched")
+        elif token and len(token) < 100 and "++" in token:
+            # If token is in "app_id++app_secret" format, fetch the tenant_access_token
+            debug_log(config, "send_lark_webclient: parsing token in app_id++app_secret format")
+            parts = token.split("++")
+            if len(parts) == 2:
+                token = self.get_tenant_access_token(config, parts[0], parts[1])
+                debug_log(config, "send_lark_webclient: tenant access token fetched from parsed token")
+        
+        # Get chat_id from channel name
+        debug_log(config, f"send_lark_webclient: resolving chat_id for channel '{config.channel}'")
+        chat_id = self.get_chat_id_from_channel_name(config, token, config.channel)
+        debug_log(config, f"send_lark_webclient: resolved chat_id")
+        
+        url = "https://open.larksuite.com/open-apis/im/v1/messages?receive_id_type=chat_id"
+        headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
+        payload = {
+            "receive_id": chat_id,
+            "msg_type": "post",
+            "content": {
+                "post": {
+                    "zh_cn": {
+                        "title": title,
+                        "content": [
+                            [
+                                {
+                                    "tag": "text",
+                                    "text": formatted_message
+                                }
+                            ]
+                        ]
+                    }
+                }
+            }
+        }
+        debug_log(config, f"send_lark_webclient: sending HTTP request, payload size: {len(str(payload))}, payload: {json.dumps(payload)}")
+        
+        response = requests.post(url, headers=headers, json=payload)
+        debug_log(config, f"send_lark_webclient: response status: {response.status_code}")
+        if response.status_code != 200:
+            error_msg = f"Lark WebClient response: {response.status_code}"
+            debug_log(config, f"send_lark_webclient: error: {error_msg}")
+            raise Exception(error_msg)
+        debug_log(config, "send_lark_webclient: message sent successfully")
+
+    def _send_lark_webhook(self, title, formatted_message, config):
+        debug_log(config, "send_lark_webhook: preparing webhook request")
+        # For webhook, the token field contains the webhook URL
+        webhook_url = config.token
+        if not webhook_url:
+            error_msg = "Webhook URL is required for Lark webhook method"
+            debug_log(config, f"Error: {error_msg}")
+            raise Exception(error_msg)
+        
+        debug_log(config, "send_lark_webhook: using webhook URL")
+        payload = {
+            "msg_type": "post",
+            "content": {
+                "post": {
+                    "zh_cn": {
+                        "title": title,
+                        "content": [
+                            [
+                                {
+                                    "tag": "text",
+                                    "text": formatted_message
+                                }
+                            ]
+                        ]
+                    }
+                }
+            }
+        }
+        debug_log(config, f"send_lark_webhook: payload prepared, size: {len(str(payload))}, payload: {json.dumps(payload)}")
+        response = requests.post(webhook_url, json=payload)
+        debug_log(config, f"send_lark_webhook: response status: {response.status_code}, response data: {response.text}")
+        if response.status_code != 200:
+            error_msg = f"Lark webhook response: {response.status_code}"
+            debug_log(config, f"send_lark_webhook: error: {error_msg}")
+            raise Exception(error_msg)
+        debug_log(config, "send_lark_webhook: webhook sent successfully")

pycommonlog/providers/redis_client.py

@@ -0,0 +1,51 @@
+"""
+Redis client for commonlog (Python)
+"""
+
+class RedisConfigError(Exception):
+    pass
+
+def get_redis_client(config):
+    import redis  # Import lazily to avoid distutils issues in Python 3.12+
+    provider_config = getattr(config, 'provider_config', {})
+    host = provider_config.get('redis_host')
+    port = provider_config.get('redis_port')
+    password = provider_config.get('redis_password')
+    ssl = provider_config.get('redis_ssl', False)
+    cluster_mode = provider_config.get('redis_cluster_mode', False)
+    db = provider_config.get('redis_db', 0)
+
+    if not host or not port:
+        raise RedisConfigError("redis_host and redis_port must be set in provider_config")
+
+    if cluster_mode:
+        # Use RedisCluster for cluster mode (ElastiCache with cluster mode enabled)
+        try:
+            from redis.cluster import RedisCluster
+        except ImportError:
+            raise RedisConfigError("Redis cluster support is not available. Please upgrade redis package to version 4.0.0 or later")
+
+        # For cluster mode, we need to handle startup nodes differently
+        # ElastiCache cluster mode provides a single endpoint
+        startup_nodes = [{"host": host, "port": int(port)}]
+
+        return RedisCluster(
+            startup_nodes=startup_nodes,
+            password=password,
+            ssl=ssl,
+            decode_responses=True,
+            skip_full_coverage_check=True,  # Allow partial cluster access
+        )
+    else:
+        # Standard Redis client for single node or ElastiCache without cluster mode
+        return redis.StrictRedis(
+            host=host,
+            port=int(port),
+            password=password,
+            db=int(db),
+            ssl=ssl,
+            decode_responses=True,
+            socket_connect_timeout=5,
+            socket_timeout=5,
+            retry_on_timeout=True,
+        )

pycommonlog/providers/slack.py

@@ -0,0 +1,103 @@
+"""
+Slack Provider for commonlog
+"""
+import requests
+import sys
+import os
+
+# Add parent directory to path for imports
+_parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if _parent_dir not in sys.path:
+    sys.path.insert(0, _parent_dir)
+
+from log_types import SendMethod, Provider, debug_log
+
+class SlackProvider(Provider):
+    def send_to_channel(self, level, message, attachment, config, channel):
+        original_channel = config.channel
+        config.channel = channel
+        self.send(level, message, attachment, config)
+        config.channel = original_channel
+
+    def send(self, level, message, attachment, config):
+        debug_log(config, f"SlackProvider.send called with level: {level}, send method: {config.send_method}")
+        formatted_message = self._format_message(message, attachment, config)
+        if config.send_method == SendMethod.WEBCLIENT:
+            debug_log(config, "Using Slack webclient method")
+            self._send_slack_webclient(formatted_message, config)
+        elif config.send_method == SendMethod.WEBHOOK:
+            debug_log(config, "Using Slack webhook method")
+            self._send_slack_webhook(formatted_message, config)
+        else:
+            error_msg = f"Unknown send method for Slack: {config.send_method}"
+            debug_log(config, f"Error: {error_msg}")
+            raise ValueError(error_msg)
+
+    def _format_message(self, message, attachment, config):
+        formatted = ""
+
+        # Add service and environment header
+        if config.service_name and config.environment:
+            formatted += f"*[{config.service_name} - {config.environment}]*\n"
+        elif config.service_name:
+            formatted += f"*[{config.service_name}]*\n"
+        elif config.environment:
+            formatted += f"*[{config.environment}]*\n"
+
+        formatted += message
+
+        if attachment and attachment.content:
+            filename = attachment.file_name or "Trace Logs"
+            formatted += f"\n\n*{filename}:*\n```\n{attachment.content}\n```"
+        if attachment and attachment.url:
+            formatted += f"\n\n*Attachment:* {attachment.url}"
+
+        return formatted
+
+    def _send_slack_webclient(self, formatted_message, config):
+        debug_log(config, "send_slack_webclient: preparing API request")
+        # Use slack_token if available, otherwise fall back to token
+        token = config.provider_config.get("token", "")
+        slack_token = config.provider_config.get("slack_token", "")
+        if slack_token:
+            token = slack_token
+            debug_log(config, "send_slack_webclient: using slack_token")
+        else:
+            debug_log(config, "send_slack_webclient: using token")
+        
+        url = "https://slack.com/api/chat.postMessage"
+        headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json; charset=utf-8"}
+        payload = {"channel": config.channel, "text": formatted_message}
+        debug_log(config, f"send_slack_webclient: sending to channel: {config.channel}, payload size: {len(str(payload))}")
+        
+        response = requests.post(url, headers=headers, json=payload)
+        debug_log(config, f"send_slack_webclient: response status: {response.status_code}, response data: {response.text}")
+        if response.status_code != 200:
+            error_msg = f"Slack WebClient response: {response.status_code}"
+            debug_log(config, f"send_slack_webclient: error: {error_msg}")
+            raise Exception(error_msg)
+        debug_log(config, "send_slack_webclient: message sent successfully")
+
+    def _send_slack_webhook(self, formatted_message, config):
+        debug_log(config, "send_slack_webhook: preparing webhook request")
+        # For webhook, the token field contains the webhook URL
+        webhook_url = config.provider_config.get("token", "")
+        if not webhook_url:
+            error_msg = "Webhook URL is required for Slack webhook method"
+            debug_log(config, f"Error: {error_msg}")
+            raise Exception(error_msg)
+        
+        debug_log(config, f"send_slack_webhook: using webhook URL, channel: {config.channel}")
+        payload = {"text": formatted_message}
+        # If channel is specified, include it in the payload
+        if config.channel:
+            payload["channel"] = config.channel
+        
+        debug_log(config, f"send_slack_webhook: payload prepared, size: {len(str(payload))}")
+        response = requests.post(webhook_url, json=payload)
+        debug_log(config, f"send_slack_webhook: response status: {response.status_code}, response data: {response.text}")
+        if response.status_code != 200:
+            error_msg = f"Slack webhook response: {response.status_code}"
+            debug_log(config, f"send_slack_webhook: error: {error_msg}")
+            raise Exception(error_msg)
+        debug_log(config, "send_slack_webhook: webhook sent successfully")

{pycommonlog-0.2.0.dist-info → pycommonlog-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycommonlog
-Version: 0.2.0
+Version: 0.2.2
 Summary: Unified logging and alerting library for Python.
 Home-page: https://github.com/alvianhanif/pycommonlog
 Author: Alvian Rahman Hanif
@@ -12,6 +12,9 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: requests
+Provides-Extra: redis
+Requires-Dist: redis>=4.0.0; extra == "redis"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -20,6 +23,8 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
 Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
@@ -50,13 +55,13 @@ from pycommonlog import commonlog, Config, SendMethod, AlertLevel, Attachment, L
 
 # Configure logger
 config = Config(
-    provider="lark", # or "slack"
     send_method=SendMethod.WEBCLIENT,
-    token="app_id++app_secret", # for Lark, use "app_id++app_secret" format
-    slack_token="xoxb-your-slack-token", # dedicated Slack token
-    lark_token=LarkToken(app_id="your-app-id", app_secret="your-app-secret"), # dedicated Lark token
     channel="your_lark_channel_id",
     provider_config={
+        "provider": "lark", # or "slack"
+        "token": "app_id++app_secret", # for Lark, use "app_id++app_secret" format
+        "slack_token": "xoxb-your-slack-token", # dedicated Slack token
+        "lark_token": LarkToken(app_id="your-app-id", app_secret="your-app-secret"), # dedicated Lark token
         "redis_host": "localhost",  # required for Lark
         "redis_port": 6379,         # required for Lark
     }
@@ -95,13 +100,13 @@ WebClient uses the full API with authentication tokens:
 
 ```python
 config = Config(
-    provider="lark",
     send_method=SendMethod.WEBCLIENT,
-    token="app_id++app_secret",  # for Lark
-    slack_token="xoxb-your-slack-token",  # for Slack
-    lark_token=LarkToken(app_id="your-app-id", app_secret="your-app-secret"),
     channel="your_channel",
     provider_config={
+        "provider": "lark",  # or "slack"
+        "token": "app_id++app_secret",  # for Lark
+        "slack_token": "xoxb-your-slack-token",  # for Slack
+        "lark_token": LarkToken(app_id="your-app-id", app_secret="your-app-secret"),
         "redis_host": "localhost",  # required for Lark
         "redis_port": 6379,         # required for Lark
     }
@@ -114,10 +119,12 @@ Webhook is simpler and requires only a webhook URL:
 
 ```python
 config = Config(
-    provider="slack",
     send_method=SendMethod.WEBHOOK,
-    token="https://hooks.slack.com/services/YOUR/WEBHOOK/URL",
     channel="optional-channel-override",  # optional
+    provider_config={
+        "provider": "slack",
+        "token": "https://hooks.slack.com/services/YOUR/WEBHOOK/URL",
+    }
 )
 ```
 
@@ -129,11 +136,11 @@ Lark integration requires proper token configuration for authentication. You can
 
 ```python
 config = Config(
-    provider="lark",
     send_method=SendMethod.WEBCLIENT,
-    token="your_app_id++your_app_secret",  # Combined format: app_id++app_secret
     channel="your_channel_id",
     provider_config={
+        "provider": "lark",
+        "token": "your_app_id++your_app_secret",  # Combined format: app_id++app_secret
         "redis_host": "localhost",  # Optional: enables caching
         "redis_port": 6379,
     }
@@ -143,17 +150,15 @@ config = Config(
 #### Method 2: Dedicated Lark Token Object
 
 ```python
-from pycommonlog import LarkToken
-
 config = Config(
-    provider="lark",
     send_method=SendMethod.WEBCLIENT,
-    lark_token=LarkToken(
-        app_id="your_app_id",
-        app_secret="your_app_secret"
-    ),
     channel="your_channel_id",
     provider_config={
+        "provider": "lark",
+        "lark_token": LarkToken(
+            app_id="your_app_id",
+            app_secret="your_app_secret"
+        ),
         "redis_host": "localhost",  # Optional: enables caching
         "redis_port": 6379,
     }
@@ -199,12 +204,14 @@ resolver = DefaultChannelResolver(
 
 # Create config with channel resolver
 config = Config(
-    provider="slack",
     send_method=SendMethod.WEBCLIENT,
-    token="xoxb-your-slack-bot-token",
     channel_resolver=resolver,
     service_name="user-service",
-    environment="production"
+    environment="production",
+    provider_config={
+        "provider": "slack",
+        "token": "xoxb-your-slack-bot-token",
+    }
 )
 
 logger = commonlog(config)
@@ -234,17 +241,27 @@ class CustomResolver(ChannelResolver):
 
 ### Common Settings
 
-- **provider**: `"slack"` or `"lark"`
-- **send_method**: `"webclient"` (token-based authentication)
+- **send_method**: `"webclient"` (token-based authentication) or `"webhook"`
 - **channel**: Target channel or chat ID (used if no resolver)
 - **channel_resolver**: Optional resolver for dynamic channel mapping
 - **service_name**: Name of the service sending alerts
 - **environment**: Environment (dev, staging, production)
 - **debug**: `True` to enable detailed debug logging of all internal processes
 
-### Provider-Specific
+### ProviderConfig Settings
 
-- **token**: API token for WebClient authentication (required)
+All provider-specific configuration is now done via the `provider_config` dict:
+
+- **provider**: `"slack"` or `"lark"`
+- **token**: API token for WebClient authentication or webhook URL for Webhook method
+- **slack_token**: Dedicated Slack token (optional, overrides token for Slack)
+- **lark_token**: `LarkToken` object with app_id and app_secret (optional, overrides token for Lark)
+- **redis_host**: Redis host for Lark caching (optional)
+- **redis_port**: Redis port for Lark caching (optional)
+- **redis_password**: Redis password (optional)
+- **redis_ssl**: Enable SSL for Redis (optional)
+- **redis_cluster_mode**: Enable Redis cluster mode (optional)
+- **redis_db**: Redis database number (optional)
 
 ## Alert Levels
 

pycommonlog-0.2.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+pycommonlog/__init__.py,sha256=ide8ECcqnHuEbimAz5yT5GIGYWyEVlrxkefvxcFLYII,480
+pycommonlog/cache.py,sha256=UFmwZ2gtsHwn1b0IOUYr4m1v_wnuey4TeMW44m2c-XI,2662
+pycommonlog/log_types.py,sha256=j8YgqsvIHfpdYexH2reTuG4QsZi1vWtk5hkkBD6mYVM,2661
+pycommonlog/logger.py,sha256=4b3mBTIUoxZsew8sOGN1IRniUgzOX-wxIJBpHMKmTfY,7137
+pycommonlog/providers/__init__.py,sha256=NfIV3103q6ZMPMiJCeS_I9sPZ7XQNyk3bFSe0Kh4xPE,148
+pycommonlog/providers/lark.py,sha256=3h2u5lziJUu4cE7HapuCqGQ9qn-zu--_lUSDXX9yjRg,12464
+pycommonlog/providers/redis_client.py,sha256=rOkj4_Wpa13scyqtTyDpkkZjXGbnA5iiX4hzcCUcUY8,1855
+pycommonlog/providers/slack.py,sha256=8AgBa4Sc74hKPsl6avxO6SpmwhByQ7b1pWYTSX26Tnc,4923
+pycommonlog-0.2.2.dist-info/licenses/LICENSE,sha256=bxyMRuc_Y6GKeCFV0_vcJf24FqyCVNL_mtUaJ7lfuFo,1075
+pycommonlog-0.2.2.dist-info/METADATA,sha256=6KN4mrCiQO2eLi0Wguus5mrXScXvVGIANtS-SpeuuD4,9733
+pycommonlog-0.2.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pycommonlog-0.2.2.dist-info/top_level.txt,sha256=tHB8NrMYpDeBGSIsRB3JZ17XMlpdTZWKQ-Ejdg_wUb4,12
+pycommonlog-0.2.2.dist-info/RECORD,,

pycommonlog-0.2.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-pycommonlog/__init__.py,sha256=ide8ECcqnHuEbimAz5yT5GIGYWyEVlrxkefvxcFLYII,480
-pycommonlog/cache.py,sha256=UFmwZ2gtsHwn1b0IOUYr4m1v_wnuey4TeMW44m2c-XI,2662
-pycommonlog/log_types.py,sha256=uXtEunhuOToU409-QaJ0YjmQhyuxixYRgHxHjl4VQcQ,2140
-pycommonlog/logger.py,sha256=rO_nSEb1IyYcTFzzv6kENe9yy-E_NTTudP-73nrDmpc,7073
-pycommonlog-0.2.0.dist-info/licenses/LICENSE,sha256=bxyMRuc_Y6GKeCFV0_vcJf24FqyCVNL_mtUaJ7lfuFo,1075
-pycommonlog-0.2.0.dist-info/METADATA,sha256=4qz3wA4NfsSx8sdWU5B5bRi_KpO4wTFA9S-AySshKtk,8806
-pycommonlog-0.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-pycommonlog-0.2.0.dist-info/top_level.txt,sha256=tHB8NrMYpDeBGSIsRB3JZ17XMlpdTZWKQ-Ejdg_wUb4,12
-pycommonlog-0.2.0.dist-info/RECORD,,