lesscode-flask 0.2.12__tar.gz → 0.2.14__tar.gz

{lesscode_flask-0.2.12 → lesscode_flask-0.2.14}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.1
 Name: lesscode-flask
-Version: 0.2.12
+Version: 0.2.14
 Summary: lesscode-flask 是基于flask的web开发脚手架项目，该项目初衷为简化开发过程，让研发人员更加关注业务。
 Home-page: https://lesscode-flask
 Author: Chao.yy
@@ -26,16 +26,6 @@ Requires-Dist: gevent==25.5.1
 Requires-Dist: openpyxl==3.1.5
 Requires-Dist: iputil==0.3.1
 Requires-Dist: phone==0.4.5
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: platform
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 # lesscode-flask
 

{lesscode_flask-0.2.12 → lesscode_flask-0.2.14}/lesscode_flask/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '0.2.12'
+__version__ = '0.2.14'
 
 import functools
 import logging

{lesscode_flask-0.2.12 → lesscode_flask-0.2.14}/lesscode_flask/app.py

@@ -24,7 +24,7 @@ from lesscode_flask.utils.decorator.sql_injection import contains_sql_injection
 from lesscode_flask.utils.helpers import inject_args, generate_uuid, app_config
 from lesscode_flask.utils.json.NotSortJSONProvider import NotSortJSONProvider
 from lesscode_flask.utils.limit import RedisRateLimiter
-from lesscode_flask.utils.limit.limit_util import get_rate_limit_info, get_count_limit_info
+from lesscode_flask.utils.limit.limit_util import get_rate_limit_info, get_count_limit_info, get_user_limit_policy
 from lesscode_flask.utils.limit.req.rate_limiter_handler import RateLimitHandler
 from lesscode_flask.utils.limit.req_count.count_limiter_handler import CountLimitHandler
 from lesscode_flask.utils.limit.req_count.redis_count_limiter import RedisCountLimiter
@@ -69,14 +69,19 @@ class Lesscoder(Flask):
 
     def preprocess_request(self) -> ft.ResponseReturnValue | None:
         v = super(Lesscoder, self).preprocess_request()
+        user_limit_policy = None
         if  hasattr(self, 'countLimiter') and self.countLimiter:
-            allowed, remaining = self.countLimiter.is_allowed(*get_count_limit_info())
+            if not user_limit_policy:
+                user_limit_policy = get_user_limit_policy()
+            allowed, remaining = self.countLimiter.is_allowed(user_limit_policy)
             if not allowed:
                 countLimitHandler =  self.config.get("COUNT_LIMIT_HANDLER", CountLimitHandler)
                 countLimitHandler(request,remaining).response_handler()
         if  hasattr(self, 'rateLimiter') and self.rateLimiter:
+            if not user_limit_policy:
+                user_limit_policy = get_user_limit_policy()
             #  是否触发限流 延迟时间 超出数量
-            allowed,delay, excess =  self.rateLimiter.is_limited(*get_rate_limit_info())
+            allowed,delay, excess =  self.rateLimiter.is_limited(user_limit_policy)
             if not allowed :
                 rateLimitHandler = self.config.get("RATE_LIMIT_HANDLER", RateLimitHandler)
                 rateLimitHandler(request,delay, excess).response_handler()

{lesscode_flask-0.2.12 → lesscode_flask-0.2.14}/lesscode_flask/model/user.py

@@ -41,7 +41,7 @@ class User(flask_login.UserMixin, PermissionsCheckMixin):
                  email: str = None,
                  type: int = 0, account_status: str = None, permissions=[], permissions_url=[], roleIds=[],
                  client_id: str = None,
-                 sub: str = None):
+                 sub: str = None,limit_policy: str =None):
         # '账号id',
         self.id = id
         # 用户名
@@ -67,6 +67,8 @@ class User(flask_login.UserMixin, PermissionsCheckMixin):
         self.permissions_url = permissions_url
         # # 角色集合
         self.roleIds = roleIds
+        # 限速策略
+        self.limit_policy = limit_policy
 
     #
     @property
@@ -124,7 +126,8 @@ class User(flask_login.UserMixin, PermissionsCheckMixin):
             "sub": self.sub if self.sub else "",
             "permissions": json.dumps(self.permissions),
             "permissions_url": json.dumps(self.permissions_url),
-            "roleIds": json.dumps(self.roleIds)
+            "roleIds": json.dumps(self.roleIds),
+            "limit_policy": self.limit_policy
 
         }
 
@@ -136,7 +139,7 @@ class User(flask_login.UserMixin, PermissionsCheckMixin):
                     display_name=user_data.get("display_name", ""), phone_no=user_data.get("phone_no", ""),
                     email=user_data.get("email", ""), type=user_data.get("type", 0),
                     account_status=user_data.get("account_status", 1),
-                    client_id=user_data.get("client_id", ""), sub=user_data.get("sub", ""))
+                    client_id=user_data.get("client_id", ""), sub=user_data.get("sub", ""),limit_policy =user_data.get("limit_policy"))
         permissions = user_data.get("permissions", [])
         if isinstance(permissions, str):
             user.permissions = json.loads(permissions)
@@ -193,7 +196,8 @@ class User(flask_login.UserMixin, PermissionsCheckMixin):
                     phone_no=user_dict["phone_no"],
                     permissions=user_dict.get("permissions", []),
                     roleIds=user_dict["roleIds"],
-                    client_id=user_dict["client_id"]
+                    client_id=user_dict["client_id"],
+                    limit_policy = user_dict.get("limit_policy", None),
                 )
                 return user
         return User()

lesscode_flask-0.2.14/lesscode_flask/model/user_limit_policy.py

@@ -0,0 +1,58 @@
+# coding: utf-8
+import json
+from typing import Union
+
+
+class UserLimitPolicy():
+
+   def __init__(
+    self,
+    id: str= None,
+    policy_name: str= None,
+    client_id: str= None,
+    rate_limit_enable: int = 0,
+    rate_limit_window_sec: int = 10,
+    rate_limit_rate: int = 5,
+    rate_limit_burst: int = 0,
+    count_limit_enable: int = 0,
+    count_limit_window_sec: int = 43200,
+    count_limit_count: int = 500,
+    white_list: Union[str, list] = None,
+    alert_webhook_url: str = None,
+):
+    """
+    初始化 AuthUserLimitPolicy 对象。
+
+    :param policy_name: 限流策略名称
+    :param client_id: 所属应用 ID
+    :param rate_limit_enable: 是否启用频率限流（默认 0）
+    :param rate_limit_window_sec: 频率窗口时间（秒，默认 1）
+    :param rate_limit_rate: 每窗口期内允许请求数（QPS，默认 1）
+    :param rate_limit_burst: 允许突发流量数（默认 0）
+    :param count_limit_enable: 是否启用计数量限流（默认 0）
+    :param count_limit_window_sec: 计数窗口时间（秒，默认 43200）
+    :param count_limit_count: 窗口期内最大访问量（默认 500）
+    :param white_list: 限流白名单路径列表（JSON 格式）
+    :param alert_webhook_url: 报警 webhook URL
+    """
+    self.id = id
+    self.policy_name = policy_name
+    self.client_id = client_id
+    # 限流参数类型转换为int
+    self.rate_limit_enable = int(rate_limit_enable) if rate_limit_enable is not None else 0
+    self.rate_limit_window_sec = int(rate_limit_window_sec) if rate_limit_window_sec is not None else 1
+    self.rate_limit_rate = int(rate_limit_rate) if rate_limit_rate is not None else 1
+    self.rate_limit_burst = int(rate_limit_burst) if rate_limit_burst is not None else 0
+    self.count_limit_enable = int(count_limit_enable) if count_limit_enable is not None else 0
+    self.count_limit_window_sec = int(count_limit_window_sec) if count_limit_window_sec is not None else 43200
+    self.count_limit_count = int(count_limit_count) if count_limit_count is not None else 500
+    self.alert_webhook_url = alert_webhook_url
+
+    # 修改后的 white_list 处理逻辑
+    if isinstance(white_list, str):
+        self.white_list = json.loads(white_list) if white_list else []
+    elif isinstance(white_list, list):
+        self.white_list = white_list
+    else:
+        self.white_list = []
+

{lesscode_flask-0.2.12 → lesscode_flask-0.2.14}/lesscode_flask/setting/__init__.py

@@ -94,28 +94,32 @@ class BaseConfig:
     RATE_LIMIT_ENABLE: bool = False
     # 触发限流的处理函数
     RATE_LIMIT_HANDLER = RateLimitHandler
-    # 限流频率窗口 单位是每秒
-    RATE_LIMIT_TIME_WINDOW = 1
-    # 限流频率
-    RATE_LIMIT_RATE = 1
-    # 限流频率允许的突发值 请求速率超过（rate + brust）的请求会被直接拒绝。
-    RATE_LIMIT_BURST = 0
+    # # 限流频率窗口 单位是每秒
+    # RATE_LIMIT_TIME_WINDOW = 1
+    # # 限流频率
+    # RATE_LIMIT_RATE = 1
+    # # 限流频率允许的突发值 请求速率超过（rate + brust）的请求会被直接拒绝。
+    # RATE_LIMIT_BURST = 0
 
     # 是否启用限流计数验证
     COUNT_LIMIT_ENABLE: bool = False
     # 触发限流的处理函数
     COUNT_LIMIT_HANDLER = CountLimitHandler
-    # 窗口期内最大访问量
-    COUNT_LIMIT_COUNT = 500
-    # 窗口期时长 单位秒
-    COUNT_LIMIT_TIME_WINDOW = 60*60*12
+    # # 窗口期内最大访问量
+    # COUNT_LIMIT_COUNT = 500
+    # # 窗口期时长 单位秒
+    # COUNT_LIMIT_TIME_WINDOW = 60*60*12
     # 白名单
     LIMIT_WHITE_LIST: list = ["/ike2b/user/WXOA/login", "/ike2b/detail/company/node/get_note",
-                                     "/ike2b/user/attention/attention_company_status",
-                                     "/ike2b/pay/wx_pay/sq_coin/get_payment_status",
-                                     "/toolEngine/targetedInvestmentPromotion/get_reach_chain",
-                                     "/ike2b/user/WXOA/bind", "/ike2b/select/park/park_list",
-                                     "/ike2b/pool/company/area_distribution/park_company_count_by_special_tag"]
+     "/ike2b/user/attention/attention_company_status",
+     "/ike2b/pay/wx_pay/sq_coin/get_payment_status",
+     "/toolEngine/targetedInvestmentPromotion/get_reach_chain",
+     "/ike2b/user/WXOA/bind", "/ike2b/select/park/park_list",
+     "/ike2b/pool/company/area_distribution/park_company_count_by_special_tag",
+     "/ike2b/pool/region/list/search_region_list_by_range",
+     "/ike2b/pool/park/list/search_park_list_by_range",
+     ]
+
     # 飞书 webhook URL 常量定义  用于向指定的飞书机器人发送消息的 webhook 地址
     LIMIT_FS_WEBHOOK_URL = "https://open.feishu.cn/open-apis/bot/v2/hook/545140ef-8234-4167-9f0c-8ee72abae430"
 

{lesscode_flask-0.2.12 → lesscode_flask-0.2.14}/lesscode_flask/utils/limit/limit_util.py

@@ -3,7 +3,11 @@ import hashlib
 from flask import request, current_app
 
 from lesscode_flask.model.user import flask_login
+from lesscode_flask.model.user_limit_policy import UserLimitPolicy
 from lesscode_flask.utils.helpers import app_config
+from lesscode_flask.utils.redis.redis_helper import RedisHelper
+
+
 def limit_key_encode() -> str:
     limit_key = None
     # 白名单
@@ -25,6 +29,25 @@ def limit_key_encode() -> str:
     limit_key = hashlib.md5(limit_key.encode('utf-8')).hexdigest()
     return hashlib.md5(limit_key.encode('utf-8')).hexdigest()
 
+def limit_key(request_url) -> str:
+    """
+    构建访问计数信息的redis 缓存key
+    :param request_url:
+    :return:
+    """
+    limit_key = None
+    # 1、获取当前用户
+    current_user = flask_login.current_user
+    if current_user and not current_user.is_anonymous_user:
+        user_id = current_user.id
+        # 拼接 key 用户id+url
+        limit_key = f"{user_id}:{request_url}"
+    # 如果键为空，使用客户端IP
+    if not limit_key:
+        limit_key = f"{request.remote_addr}{request_url}"
+    # 对键进行哈希处理，避免键过长
+    limit_key = hashlib.md5(limit_key.encode('utf-8')).hexdigest()
+    return limit_key
 
 def get_rate_limit_info() -> str:
     """
@@ -47,5 +70,32 @@ def get_count_limit_info() -> str:
     # 窗口期时长 单位秒
     time_window = app_config.get("COUNT_LIMIT_TIME_WINDOW",3600)
     limit_key = limit_key_encode()
+    user_limit_policy = get_user_limit_policy()
     return limit_key, count, time_window
 
+
+def get_user_limit_policy():
+    limit_policy_id = None  # 初始化变量
+    user_limit_policy = None  # 初始化变量
+    REDIS_OAUTH_KEY = app_config.get("REDIS_OAUTH_KEY", "redis")
+
+    # 1、获取当前用户
+    current_user = flask_login.current_user
+    if current_user and not current_user.is_anonymous_user:
+        limit_policy_id = current_user.limit_policy
+        # item["white_list"] = json.dumps(item.get("white_list", []))
+    if limit_policy_id:
+        key = f"limit_policy:{limit_policy_id}"
+        limit_policy_id = RedisHelper(REDIS_OAUTH_KEY).sync_hgetall(key)
+        user_limit_policy = UserLimitPolicy(**limit_policy_id)
+
+    if user_limit_policy:
+        return user_limit_policy
+    else:
+        # 如果没有策略就构建默认策略
+        REDIS_RATE_LIMIT_ENABLE = app_config.get("RATE_LIMIT_ENABLE", False)
+        REDIS_COUNT_LIMIT_ENABLE = app_config.get("COUNT_LIMIT_ENABLE", False)
+        LIMIT_WHITE_LIST = app_config.get("LIMIT_WHITE_LIST", False)
+        return UserLimitPolicy(rate_limit_enable=int(REDIS_RATE_LIMIT_ENABLE),
+                               count_limit_enable=int(REDIS_COUNT_LIMIT_ENABLE),white_list=LIMIT_WHITE_LIST)
+

lesscode_flask-0.2.14/lesscode_flask/utils/limit/req/redis_rate_limiter.py

@@ -0,0 +1,113 @@
+import time
+import logging
+
+from flask import request
+
+from lesscode_flask.model.user_limit_policy import UserLimitPolicy
+from lesscode_flask.utils.limit.limit_util import limit_key
+from lesscode_flask.utils.redis.redis_helper import RedisHelper
+
+logger = logging.getLogger(__name__)
+
+
+class RedisRateLimiter:
+    """
+    Redis限流实现
+    """
+
+    def __init__(self, redis_key):
+        self.redis_key = redis_key
+
+    def is_limited(self,user_limit_policy: UserLimitPolicy) -> tuple:
+        """
+        检查是否触发限流
+        :param user_limit_policy: 策略信息
+        :return: (allowed,delay, excess) 是否触发限流 延迟时间和超出数量
+        """
+
+        rate: float = user_limit_policy.rate_limit_rate
+        burst: float = user_limit_policy.rate_limit_burst
+        time_window: int = user_limit_policy.rate_limit_window_sec
+        rate_limit_enable = user_limit_policy.rate_limit_enable
+        limit_white_list = user_limit_policy.white_list
+        request_url = request.url_rule.rule
+        # 未启用限流 或者 在白名单中 直接返回允许
+        if rate_limit_enable == 0 or  request_url in limit_white_list:
+            # 白名单访问 直接返回None
+            return True, 0, 0
+        # 构造Redis键
+        key = f"limit_req:{limit_key(request_url)}"
+        # 存储键的键
+        excess_key = f"{key}excess"
+        # 存储最近一次请求时间毫秒的键
+        last_key = f"{key}last"
+        # 当前时间的毫秒表示形式
+        now = time.time() * 1000  # 转换为毫秒
+
+        try:
+            # 获取上次记录的信息
+            excess = RedisHelper(self.redis_key).sync_get(excess_key)
+            last =RedisHelper(self.redis_key).sync_get(last_key)
+
+            if excess is not None and last is not None:
+                excess = float(excess)
+                # 获取最近一次请求的时间毫秒值
+                last = float(last)
+                # 计算当前与最近一次访问的时间差
+                elapsed = now - last
+                # 根据时间差计算当前的excess值
+                excess = max(excess - (rate * abs(elapsed) / 1000*time_window) + 1, 0)
+            else:
+                excess = 0
+            # 返回延迟时间和超出数量
+            delay = excess / rate
+            # 检查是否超出限制
+            if excess > burst+rate:
+                return False, delay, excess # 被拒绝
+            # 更新Redis中的值
+            RedisHelper(self.redis_key).sync_set(excess_key, excess)
+            RedisHelper(self.redis_key).sync_set(last_key, now)
+            return True,delay, excess
+
+        except Exception as e:
+            logger.error(f"Redis rate limiter error: {e}")
+            return True, 0,0
+        # if not key: # 没有key表示不验证
+        #     return True, 0,0
+        # # 构造Redis键
+        # key = f"limit_req:{key}"
+        # # 存储键的键
+        # excess_key = f"{key}excess"
+        # # 存储最近一次请求时间毫秒的键
+        # last_key = f"{key}last"
+        # # 当前时间的毫秒表示形式
+        # now = time.time() * 1000  # 转换为毫秒
+        #
+        # try:
+        #     # 获取上次记录的信息
+        #     excess = RedisHelper(self.redis_key).sync_get(excess_key)
+        #     last =RedisHelper(self.redis_key).sync_get(last_key)
+        #
+        #     if excess is not None and last is not None:
+        #         excess = float(excess)
+        #         # 获取最近一次请求的时间毫秒值
+        #         last = float(last)
+        #         # 计算当前与最近一次访问的时间差
+        #         elapsed = now - last
+        #         # 根据时间差计算当前的excess值
+        #         excess = max(excess - (rate * abs(elapsed) / 1000*time_window) + 1, 0)
+        #     else:
+        #         excess = 0
+        #     # 返回延迟时间和超出数量
+        #     delay = excess / rate
+        #     # 检查是否超出限制
+        #     if excess > burst+rate:
+        #         return False, delay, excess # 被拒绝
+        #     # 更新Redis中的值
+        #     RedisHelper(self.redis_key).sync_set(excess_key, excess)
+        #     RedisHelper(self.redis_key).sync_set(last_key, now)
+        #     return True,delay, excess
+        #
+        # except Exception as e:
+        #     logger.error(f"Redis rate limiter error: {e}")
+        #     return True, 0,0

{lesscode_flask-0.2.12 → lesscode_flask-0.2.14}/lesscode_flask/utils/limit/req_count/redis_count_limiter.py

@@ -1,4 +1,9 @@
 import logging
+
+from flask import request
+
+from lesscode_flask.model.user_limit_policy import UserLimitPolicy
+from lesscode_flask.utils.limit.limit_util import limit_key
 from lesscode_flask.utils.redis.redis_helper import RedisHelper
 
 logger = logging.getLogger(__name__)
@@ -9,18 +14,23 @@ class RedisCountLimiter:
     def __init__(self, redis_key):
         self.redis_key = redis_key
 
-    def is_allowed(self, key, count, time_window, cost=1):
+    def is_allowed(self, user_limit_policy: UserLimitPolicy):
         """
         检查是否允许请求
-        :param key: 限流键
-        :param count: 时间窗口内的请求数量限制
-        :param time_window: 时间窗口（秒）
-        :param cost: 本次请求消耗的令牌数
         :return: (allowed, remaining)
         """
-        if not key: # 没有key表示不验证
-            return True, 0
-        key = f"limit_count:{key}"
+        count = user_limit_policy.count_limit_count
+        time_window = user_limit_policy.count_limit_window_sec
+        count_limit_enable = user_limit_policy.count_limit_enable
+        limit_white_list = user_limit_policy.white_list
+        cost = 1 # 每次消耗一次数
+        request_url = request.url_rule.rule
+        # 未启用限流 或者 在白名单中 直接返回允许
+        if count_limit_enable == 0 or request_url in limit_white_list:
+            # 白名单访问 直接返回None
+            return True, 0, 0
+        #  限流键
+        key = f"limit_count:{limit_key(request_url)}"
 
         try:
             remaining = RedisHelper(self.redis_key).sync_get(key)
@@ -28,7 +38,7 @@ class RedisCountLimiter:
                 remaining = count-cost
                 RedisHelper(self.redis_key).sync_set(key,remaining,time_window)
             else:
-                # 键存在，减少令牌数
+                # 键存在，每次减少相应数量
                 remaining = RedisHelper(self.redis_key).sync_incrby(name=key,amount=0- cost)
             if remaining < 0:
                 return False, remaining

{lesscode_flask-0.2.12 → lesscode_flask-0.2.14}/lesscode_flask.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.1
 Name: lesscode-flask
-Version: 0.2.12
+Version: 0.2.14
 Summary: lesscode-flask 是基于flask的web开发脚手架项目，该项目初衷为简化开发过程，让研发人员更加关注业务。
 Home-page: https://lesscode-flask
 Author: Chao.yy
@@ -26,16 +26,6 @@ Requires-Dist: gevent==25.5.1
 Requires-Dist: openpyxl==3.1.5
 Requires-Dist: iputil==0.3.1
 Requires-Dist: phone==0.4.5
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: platform
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 # lesscode-flask
 

{lesscode_flask-0.2.12 → lesscode_flask-0.2.14}/lesscode_flask.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ lesscode_flask/model/parameterized_query.py
 lesscode_flask/model/resource_param_template.py
 lesscode_flask/model/response_result.py
 lesscode_flask/model/user.py
+lesscode_flask/model/user_limit_policy.py
 lesscode_flask/service/access_log_service.py
 lesscode_flask/service/base_service.py
 lesscode_flask/service/resource_param_template_service.py

lesscode_flask-0.2.12/lesscode_flask/utils/limit/req/redis_rate_limiter.py

@@ -1,63 +0,0 @@
-import time
-import logging
-from lesscode_flask.utils.redis.redis_helper import RedisHelper
-
-logger = logging.getLogger(__name__)
-
-
-class RedisRateLimiter:
-    """
-    Redis限流实现
-    """
-
-    def __init__(self, redis_key):
-        self.redis_key = redis_key
-
-    def is_limited(self, key: str, rate: float, burst: float,time_window:int=1) -> tuple:
-        """
-        检查是否触发限流
-        :param key: 限流键
-        :param rate: 每秒请求速率
-        :param burst: 突发请求数
-        :param time_window: 窗口期
-        :return: (allowed,delay, excess) 是否触发限流 延迟时间和超出数量
-        """
-        if not key: # 没有key表示不验证
-            return True, 0,0
-        # 构造Redis键
-        key = f"limit_req:{key}"
-        # 存储键的键
-        excess_key = f"{key}excess"
-        # 存储最近一次请求时间毫秒的键
-        last_key = f"{key}last"
-        # 当前时间的毫秒表示形式
-        now = time.time() * 1000  # 转换为毫秒
-
-        try:
-            # 获取上次记录的信息
-            excess = RedisHelper(self.redis_key).sync_get(excess_key)
-            last =RedisHelper(self.redis_key).sync_get(last_key)
-
-            if excess is not None and last is not None:
-                excess = float(excess)
-                # 获取最近一次请求的时间毫秒值
-                last = float(last)
-                # 计算当前与最近一次访问的时间差
-                elapsed = now - last
-                # 根据时间差计算当前的excess值
-                excess = max(excess - (rate * abs(elapsed) / 1000*time_window) + 1, 0)
-            else:
-                excess = 0
-            # 返回延迟时间和超出数量
-            delay = excess / rate
-            # 检查是否超出限制
-            if excess > burst+rate:
-                return False, delay, excess # 被拒绝
-            # 更新Redis中的值
-            RedisHelper(self.redis_key).sync_set(excess_key, excess)
-            RedisHelper(self.redis_key).sync_set(last_key, now)
-            return True,delay, excess
-
-        except Exception as e:
-            logger.error(f"Redis rate limiter error: {e}")
-            return True, 0,0