405 Method Not Allowed\u00a0\u72b6\u6001\u7801\u8868\u793a\u8bf7\u6c42\u884c\u4e2d\u6307\u5b9a\u7684\u65b9\u6cd5\u5bf9\u8bf7\u6c42URI\u6807\u8bc6\u7684\u8d44\u6e90\u662f\u5df2\u77e5\u7684，\u4f46\u4e0d\u88ab\u76ee\u6807\u8d44\u6e90\u652f\u6301\u3002\u670d\u52a1\u5668\u5fc5\u987b\u751f\u6210\u4e00\u4e2a\u00a0Allow\u00a0\u54cd\u5e94\u5934\u5b57\u6bb5，\u5305\u542b\u76ee\u6807\u8d44\u6e90\u5f53\u524d\u652f\u6301\u7684\u65b9\u6cd5\u5217\u8868\u3002<\/p>\n
\u6838\u5fc3\u8bed\u4e49：<\/p>\n
\u670d\u52a1\u5668\u7406\u89e3\u8bf7\u6c42，\u4f46\u660e\u786e\u62d2\u7edd\u6267\u884c\u8be5\u65b9\u6cd5<\/p>\n<\/li>\n
\u4e0e501（\u672a\u5b9e\u73b0）\u4e0d\u540c：405\u8868\u793a\u65b9\u6cd5\u6709\u6548，\u4f46\u6b64\u8d44\u6e90\u4e0d\u652f\u6301<\/p>\n<\/li>\n
\u4e0e403（\u7981\u6b62）\u4e0d\u540c：405\u662f\u5173\u4e8eHTTP\u65b9\u6cd5，\u4e0d\u662f\u8bbf\u95ee\u6743\u9650<\/p>\n<\/li>\n<\/ul>\n
\u5173\u952e\u8981\u6c42：<\/p>\n
\u5fc5\u987b\u5305\u542b\u00a0Allow\u00a0\u5934\u90e8<\/p>\n<\/li>\n
\u54cd\u5e94\u5e94\u8be5\u662f\u5ba2\u6237\u7aef\u53ef\u4ee5\u7406\u89e3\u7684<\/p>\n<\/li>\n
\u53ef\u4ee5\u5305\u542b\u54cd\u5e94\u4f53\u89e3\u91ca\u9519\u8bef\u539f\u56e0<\/p>\n<\/li>\n<\/ul>\n
python<\/p>\n
# RESTful API\u4e2d\u7684\u5178\u578b405\u573a\u666f
\nclass RESTfulAPI:
\n # 1. \u5bf9\u53ea\u8bfb\u8d44\u6e90\u4f7f\u7528\u5199\u65b9\u6cd5
\n # GET \/api\/articles\/123 \u2705
\n # PUT \/api\/articles\/123 \u274c 405<\/p>\n
# 2. \u5bf9\u53ea\u5199\u8d44\u6e90\u4f7f\u7528\u8bfb\u65b9\u6cd5
\n # POST \/api\/webhooks \u2705
\n # GET \/api\/webhooks \u274c 405<\/p>\n
# 3. \u7aef\u70b9\u4ec5\u652f\u6301\u7279\u5b9a\u65b9\u6cd5
\n # POST \/api\/auth\/login \u2705
\n # GET \/api\/auth\/login \u274c 405<\/p>\n
# 4. \u7248\u672c\u5316API\u4e2d\u7684\u65b9\u6cd5\u5f03\u7528
\n # PATCH \/api\/v2\/users\/123 \u2705
\n # PUT \/api\/v2\/users\/123 \u274c 405（PUT\u5728v2\u4e2d\u5df2\u5f03\u7528）<\/p>\n
http<\/p>\n
# \u793a\u4f8b：\u5bf9\u96c6\u5408\u4f7f\u7528\u4e0d\u9002\u5f53\u7684\u65b9\u6cd5
\nPUT \/api\/users HTTP\/1.1
\nContent-Type: application\/json
\nContent-Length: 45<\/p>\n
{"name": "John", "email": "john@example.com"}<\/p>\n
# \u54cd\u5e94 – \u5e94\u8be5\u4f7f\u7528POST\u521b\u5efa\u8d44\u6e90
\nHTTP\/1.1 405 Method Not Allowed
\nAllow: GET, POST, HEAD, OPTIONS
\nContent-Type: application\/json<\/p>\n
{
\n "error": {
\n "code": "METHOD_NOT_ALLOWED",
\n "message": "PUT method is not allowed on this collection. Use POST to create new resources.",
\n "allowed_methods": ["GET", "POST", "HEAD", "OPTIONS"],
\n "suggested_method": "POST"
\n }
\n}<\/p>\n
python<\/p>\n
# Flask\u5b9e\u73b0：\u6b63\u786e\u7684Allow\u5934\u90e8\u751f\u6210
\nfrom flask import Flask, request, jsonify
\nfrom functools import wraps
\nimport inspect<\/p>\n
class MethodAllowanceManager:
\n def __init__(self, app):
\n self.app = app
\n self.route_methods = {}
\n self.init_method_tracking()<\/p>\n
def init_method_tracking(self):
\n """\u521d\u59cb\u5316\u65b9\u6cd5\u8ddf\u8e2a"""
\n @self.app.before_request
\n def track_route():
\n # \u5b58\u50a8\u5f53\u524d\u8def\u7531\u652f\u6301\u7684\u65b9\u6cd5
\n if request.endpoint:
\n rule = self.app.url_map._rules_by_endpoint[request.endpoint][0]
\n if request.endpoint not in self.route_methods:
\n self.route_methods[request.endpoint] = set(rule.methods)<\/p>\n
def get_allowed_methods(self, endpoint):
\n """\u83b7\u53d6\u7aef\u70b9\u5141\u8bb8\u7684\u65b9\u6cd5"""
\n if endpoint in self.route_methods:
\n return self.route_methods[endpoint]<\/p>\n
# \u5982\u679c\u6ca1\u6709\u627e\u5230，\u68c0\u67e5\u6240\u6709\u53ef\u80fd\u7684\u8def\u7531
\n for rule in self.app.url_map.iter_rules():
\n if rule.endpoint == endpoint:
\n return set(rule.methods)<\/p>\n
return set()<\/p>\n
app = Flask(__name__)
\nmethod_manager = MethodAllowanceManager(app)<\/p>\n
# \u81ea\u5b9a\u4e49405\u9519\u8bef\u5904\u7406\u5668
\n@app.errorhandler(405)
\ndef handle_method_not_allowed(e):
\n """\u751f\u6210\u6b63\u786e\u7684405\u54cd\u5e94"""
\n # \u786e\u5b9a\u5f53\u524d\u7aef\u70b9
\n endpoint = request.endpoint<\/p>\n
# \u83b7\u53d6\u5141\u8bb8\u7684\u65b9\u6cd5
\n allowed_methods = method_manager.get_allowed_methods(endpoint)<\/p>\n
# \u6392\u5e8f\u65b9\u6cd5：\u5e38\u7528\u65b9\u6cd5\u5728\u524d
\n method_order = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']
\n sorted_methods = sorted(
\n allowed_methods,
\n key=lambda x: method_order.index(x) if x in method_order else len(method_order)
\n )<\/p>\n
# \u751f\u6210\u54cd\u5e94
\n response = jsonify({
\n "error": {
\n "code": "METHOD_NOT_ALLOWED",
\n "message": f"The {request.method} method is not allowed for the requested resource.",
\n "requested_method": request.method,
\n "allowed_methods": list(sorted_methods),
\n "path": request.path
\n }
\n })<\/p>\n
response.status_code = 405
\n response.headers['Allow'] = ', '.join(sorted_methods)<\/p>\n
# \u6dfb\u52a0\u7f13\u5b58\u63a7\u5236\u5934
\n response.headers['Cache-Control'] = 'no-store'<\/p>\n
return response<\/p>\n
# \u8def\u7531\u793a\u4f8b
\n@app.route('\/api\/articles', methods=['GET', 'POST'])
\ndef articles_collection():
\n """\u6587\u7ae0\u96c6\u5408 – \u652f\u6301GET\u548cPOST"""
\n if request.method == 'GET':
\n return jsonify({"articles": []})
\n else: # POST
\n return jsonify({"id": 1}), 201<\/p>\n
@app.route('\/api\/articles\/<int:article_id>', methods=['GET', 'PUT', 'DELETE'])
\ndef article_detail(article_id):
\n """\u6587\u7ae0\u8be6\u60c5 – \u652f\u6301GET\u3001PUT\u3001DELETE"""
\n if request.method == 'GET':
\n return jsonify({"id": article_id, "title": "Sample"})
\n elif request.method == 'PUT':
\n return jsonify({"updated": True}), 200
\n else: # DELETE
\n return '', 204<\/p>\n
python<\/p>\n
# \u65b9\u6cd5\u9a8c\u8bc1\u548c\u667a\u80fd\u5efa\u8bae\u4e2d\u95f4\u4ef6
\nfrom enum import Enum
\nfrom typing import Dict, List, Optional, Set
\nfrom dataclasses import dataclass
\nimport re<\/p>\n
class HTTPMethod(Enum):
\n GET = "GET"
\n POST = "POST"
\n PUT = "PUT"
\n PATCH = "PATCH"
\n DELETE = "DELETE"
\n HEAD = "HEAD"
\n OPTIONS = "OPTIONS"
\n TRACE = "TRACE"
\n CONNECT = "CONNECT"<\/p>\n
@dataclass
\nclass MethodRule:
\n """\u65b9\u6cd5\u89c4\u5219\u5b9a\u4e49"""
\n pattern: str
\n allowed_methods: Set[HTTPMethod]
\n suggestions: Dict[HTTPMethod, str] = None
\n reason: str = None<\/p>\n
class IntelligentMethodValidator:
\n """\u667a\u80fd\u65b9\u6cd5\u9a8c\u8bc1\u5668"""<\/p>\n
def __init__(self):
\n # \u5b9a\u4e49RESTful\u7ea6\u5b9a
\n self.restful_rules = [
\n # \u96c6\u5408\u7aef\u70b9
\n MethodRule(
\n pattern=r'^\/api\/([^\/]+)$',
\n allowed_methods={HTTPMethod.GET, HTTPMethod.POST, HTTPMethod.OPTIONS},
\n suggestions={
\n HTTPMethod.PUT: "Use POST to create resources in a collection",
\n HTTPMethod.DELETE: "To delete a collection, use a specific resource endpoint"
\n }
\n ),
\n # \u8d44\u6e90\u7aef\u70b9
\n MethodRule(
\n pattern=r'^\/api\/([^\/]+)\/\\\\d+$',
\n allowed_methods={HTTPMethod.GET, HTTPMethod.PUT, HTTPMethod.PATCH, HTTPMethod.DELETE, HTTPMethod.OPTIONS},
\n suggestions={
\n HTTPMethod.POST: "Use PUT or PATCH to update an existing resource"
\n }
\n ),
\n # \u5b50\u8d44\u6e90\u96c6\u5408
\n MethodRule(
\n pattern=r'^\/api\/([^\/]+)\/\\\\d+\/([^\/]+)$',
\n allowed_methods={HTTPMethod.GET, HTTPMethod.POST, HTTPMethod.OPTIONS},
\n suggestions={
\n HTTPMethod.PUT: "Use POST to create sub-resources",
\n HTTPMethod.DELETE: "To delete a sub-resource, use its specific endpoint"
\n }
\n ),
\n # \u53ea\u8bfb\u7aef\u70b9
\n MethodRule(
\n pattern=r'^\/api\/reports\/.+$',
\n allowed_methods={HTTPMethod.GET, HTTPMethod.HEAD, HTTPMethod.OPTIONS},
\n reason="This is a read-only reporting endpoint"
\n )
\n ]<\/p>\n
def validate_method(self, path: str, method: HTTPMethod, allowed_methods: Set[HTTPMethod]) -> Dict:
\n """\u9a8c\u8bc1\u65b9\u6cd5\u5e76\u63d0\u4f9b\u667a\u80fd\u53cd\u9988"""<\/p>\n
# \u57fa\u672c\u9a8c\u8bc1
\n if method in allowed_methods:
\n return {"valid": True}<\/p>\n
# \u83b7\u53d6\u667a\u80fd\u5efa\u8bae
\n suggestions = self.get_suggestions(path, method)<\/p>\n
# \u68c0\u67e5\u662f\u5426\u662f\u5e38\u89c1\u9519\u8bef
\n common_errors = self.check_common_errors(path, method)<\/p>\n
return {
\n "valid": False,
\n "allowed_methods": allowed_methods,
\n "suggestions": suggestions,
\n "common_errors": common_errors,
\n "method_meaning": self.get_method_meaning(method)
\n }<\/p>\n
def get_suggestions(self, path: str, attempted_method: HTTPMethod) -> List[str]:
\n """\u83b7\u53d6\u9488\u5bf9\u7279\u5b9a\u8def\u5f84\u548c\u65b9\u6cd5\u7684\u5efa\u8bae"""
\n suggestions = []<\/p>\n
for rule in self.restful_rules:
\n if re.match(rule.pattern, path):
\n if rule.suggestions and attempted_method in rule.suggestions:
\n suggestions.append(rule.suggestions[attempted_method])
\n if rule.reason:
\n suggestions.append(f"Reason: {rule.reason}")<\/p>\n
# \u901a\u7528\u5efa\u8bae
\n generic_suggestions = {
\n HTTPMethod.GET: ["Use GET to retrieve resources"],
\n HTTPMethod.POST: ["Use POST to create new resources"],
\n HTTPMethod.PUT: ["Use PUT to fully replace existing resources"],
\n HTTPMethod.PATCH: ["Use PATCH to partially update resources"],
\n HTTPMethod.DELETE: ["Use DELETE to remove resources"]
\n }<\/p>\n
if attempted_method in generic_suggestions:
\n suggestions.extend(generic_suggestions[attempted_method])<\/p>\n
return suggestions<\/p>\n
def check_common_errors(self, path: str, method: HTTPMethod) -> List[Dict]:
\n """\u68c0\u67e5\u5e38\u89c1\u9519\u8bef\u6a21\u5f0f"""
\n errors = []<\/p>\n
# \u68c0\u67e5\u662f\u5426\u662f\u96c6\u5408\u4e0e\u8d44\u6e90\u6df7\u6dc6
\n if method == HTTPMethod.PUT and re.match(r'^\/api\/([^\/]+)$', path):
\n errors.append({
\n "type": "collection_resource_confusion",
\n "message": "PUT is typically used for individual resources, not collections",
\n "suggestion": "Use POST to create a new resource in the collection"
\n })<\/p>\n
# \u68c0\u67e5\u662f\u5426\u8bef\u7528PATCH
\n if method == HTTPMethod.PATCH and re.match(r'^\/api\/([^\/]+)$', path):
\n errors.append({
\n "type": "patch_on_collection",
\n "message": "PATCH cannot be applied to collections",
\n "suggestion": "Apply PATCH to specific resource URLs"
\n })<\/p>\n
# \u68c0\u67e5\u662f\u5426\u4f7f\u7528DELETE\u5220\u9664\u96c6\u5408
\n if method == HTTPMethod.DELETE and re.match(r'^\/api\/([^\/]+)$', path):
\n errors.append({
\n "type": "delete_collection",
\n "message": "Collections typically don't support DELETE",
\n "suggestion": "Delete individual resources instead"
\n })<\/p>\n
return errors<\/p>\n
def get_method_meaning(self, method: HTTPMethod) -> Dict:
\n """\u83b7\u53d6HTTP\u65b9\u6cd5\u7684\u8bed\u4e49\u542b\u4e49"""
\n meanings = {
\n HTTPMethod.GET: {
\n "semantics": "Safe, idempotent retrieval",
\n "use_case": "Read data without side effects",
\n "cacheable": True
\n },
\n HTTPMethod.POST: {
\n "semantics": "Create new resource or non-idempotent operation",
\n "use_case": "Submit data, create resources",
\n "cacheable": False
\n },
\n HTTPMethod.PUT: {
\n "semantics": "Idempotent replacement",
\n "use_case": "Update entire resource",
\n "cacheable": False
\n },
\n HTTPMethod.PATCH: {
\n "semantics": "Partial update",
\n "use_case": "Update specific fields",
\n "cacheable": False
\n },
\n HTTPMethod.DELETE: {
\n "semantics": "Remove resource",
\n "use_case": "Delete existing resource",
\n "cacheable": False
\n }
\n }<\/p>\n
return meanings.get(method, {"semantics": "Unknown"})<\/p>\n
# Flask\u4e2d\u95f4\u4ef6\u96c6\u6210
\nvalidator = IntelligentMethodValidator()<\/p>\n
@app.before_request
\ndef validate_http_method():
\n """\u9a8c\u8bc1HTTP\u65b9\u6cd5"""
\n if request.method == 'OPTIONS':
\n return # OPTIONS\u603b\u662f\u5141\u8bb8\u7684<\/p>\n
# \u83b7\u53d6\u5f53\u524d\u7aef\u70b9\u5141\u8bb8\u7684\u65b9\u6cd5
\n endpoint = request.endpoint
\n if endpoint:
\n allowed_methods = method_manager.get_allowed_methods(endpoint)<\/p>\n
# \u8f6c\u6362\u4e3aHTTPMethod\u679a\u4e3e
\n allowed_methods_enum = {HTTPMethod(m) for m in allowed_methods}
\n current_method = HTTPMethod(request.method)<\/p>\n
# \u9a8c\u8bc1\u65b9\u6cd5
\n validation_result = validator.validate_method(
\n request.path,
\n current_method,
\n allowed_methods_enum
\n )<\/p>\n
if not validation_result["valid"]:
\n # \u521b\u5efa\u8be6\u7ec6\u7684405\u54cd\u5e94
\n response = jsonify({
\n "error": {
\n "code": "METHOD_NOT_ALLOWED",
\n "message": f"The {request.method} method is not supported for this endpoint.",
\n "details": {
\n "attempted_method": {
\n "name": request.method,
\n "semantics": validation_result["method_meaning"]
\n },
\n "validation_result": validation_result
\n }
\n }
\n })<\/p>\n
response.status_code = 405
\n response.headers['Allow'] = ', '.join([m.value for m in allowed_methods_enum])<\/p>\n
# \u6dfb\u52a0\u63cf\u8ff0\u6027\u5934\u90e8
\n response.headers['X-Method-Validation'] = 'failed'
\n if validation_result["suggestions"]:
\n response.headers['X-Method-Suggestions'] = '; '.join(validation_result["suggestions"])<\/p>\n
return response<\/p>\n
python<\/p>\n
# \u5b8c\u6574\u7684OPTIONS\u65b9\u6cd5\u5b9e\u73b0
\nclass OptionsHandler:
\n """\u5904\u7406OPTIONS\u8bf7\u6c42，\u63d0\u4f9bAPI\u53d1\u73b0\u529f\u80fd"""<\/p>\n
def __init__(self, app):
\n self.app = app
\n self.api_documentation = {}<\/p>\n
def generate_options_response(self, endpoint, path):
\n """\u751f\u6210OPTIONS\u54cd\u5e94"""<\/p>\n
# \u83b7\u53d6\u5141\u8bb8\u7684\u65b9\u6cd5
\n allowed_methods = method_manager.get_allowed_methods(endpoint)<\/p>\n
# \u83b7\u53d6\u7aef\u70b9\u6587\u6863
\n endpoint_docs = self.get_endpoint_documentation(endpoint, path)<\/p>\n
# \u6784\u5efa\u54cd\u5e94
\n response_body = {
\n "endpoint": endpoint,
\n "path": path,
\n "allowed_methods": list(allowed_methods),
\n "documentation": endpoint_docs,
\n "links": self.generate_links(path, allowed_methods)
\n }<\/p>\n
# \u6dfb\u52a0\u76f8\u5173\u7aef\u70b9
\n related_endpoints = self.find_related_endpoints(path)
\n if related_endpoints:
\n response_body["related_endpoints"] = related_endpoints<\/p>\n
return response_body<\/p>\n
def get_endpoint_documentation(self, endpoint, path):
\n """\u83b7\u53d6\u7aef\u70b9\u6587\u6863"""
\n if endpoint in self.api_documentation:
\n return self.api_documentation[endpoint]<\/p>\n
# \u52a8\u6001\u751f\u6210\u6587\u6863
\n return {
\n "description": self.infer_endpoint_description(path),
\n "parameters": self.infer_parameters(path),
\n "request_format": self.infer_request_format(path),
\n "response_format": self.infer_response_format(path)
\n }<\/p>\n
def infer_endpoint_description(self, path):
\n """\u63a8\u65ad\u7aef\u70b9\u63cf\u8ff0"""
\n if re.match(r'^\/api\/([^\/]+)$', path):
\n resource = re.match(r'^\/api\/([^\/]+)$', path).group(1)
\n return f"Collection of {resource} resources"
\n elif re.match(r'^\/api\/([^\/]+)\/\\\\d+$', path):
\n resource = re.match(r'^\/api\/([^\/]+)\/\\\\d+$', path).group(1)
\n return f"Individual {resource} resource"
\n return "API endpoint"<\/p>\n
def infer_parameters(self, path):
\n """\u63a8\u65ad\u53c2\u6570"""
\n parameters = {}<\/p>\n
# \u8def\u5f84\u53c2\u6570
\n path_params = re.findall(r'<([^>]+)>', path)
\n for param in path_params:
\n param_name = param.split(':')[-1] if ':' in param else param
\n parameters[param_name] = {
\n "in": "path",
\n "required": True,
\n "type": self.infer_param_type(param)
\n }<\/p>\n
return parameters<\/p>\n
def infer_param_type(self, param):
\n """\u63a8\u65ad\u53c2\u6570\u7c7b\u578b"""
\n if param.startswith('int:'):
\n return "integer"
\n elif param.startswith('float:'):
\n return "number"
\n elif param.startswith('uuid:'):
\n return "string (UUID)"
\n else:
\n return "string"<\/p>\n
def infer_request_format(self, path):
\n """\u63a8\u65ad\u8bf7\u6c42\u683c\u5f0f"""
\n # \u6839\u636e\u8def\u5f84\u6a21\u5f0f\u63a8\u65ad
\n if re.match(r'^\/api\/([^\/]+)$', path):
\n return {
\n "POST": {
\n "content-type": "application\/json",
\n "schema": {
\n "type": "object",
\n "properties": {
\n "id": {"type": "integer", "readOnly": True},
\n "name": {"type": "string"},
\n "created_at": {"type": "string", "format": "date-time", "readOnly": True}
\n }
\n }
\n }
\n }
\n return {}<\/p>\n
def infer_response_format(self, path):
\n """\u63a8\u65ad\u54cd\u5e94\u683c\u5f0f"""
\n return {
\n "application\/json": {
\n "schema": {"type": "object"}
\n }
\n }<\/p>\n
def generate_links(self, path, allowed_methods):
\n """\u751f\u6210HATEOAS\u94fe\u63a5"""
\n links = []<\/p>\n
# \u81ea\u6211\u94fe\u63a5
\n links.append({
\n "rel": "self",
\n "href": path,
\n "method": "GET" if HTTPMethod.GET in allowed_methods else "OPTIONS"
\n })<\/p>\n
# \u7236\u94fe\u63a5
\n if path != '\/':
\n parent_path = '\/'.join(path.split('\/')[:-1]) or '\/'
\n links.append({
\n "rel": "parent",
\n "href": parent_path,
\n "method": "GET"
\n })<\/p>\n
# \u76f8\u5173\u64cd\u4f5c\u94fe\u63a5
\n if HTTPMethod.POST in allowed_methods:
\n links.append({
\n "rel": "create",
\n "href": path,
\n "method": "POST"
\n })<\/p>\n
return links<\/p>\n
def find_related_endpoints(self, path):
\n """\u67e5\u627e\u76f8\u5173\u7aef\u70b9"""
\n related = []<\/p>\n
# \u67e5\u627e\u76f8\u540c\u8d44\u6e90\u7684\u4e0d\u540c\u64cd\u4f5c
\n if re.match(r'^\/api\/([^\/]+)\/\\\\d+$', path):
\n # \u8fd9\u662f\u8d44\u6e90\u8be6\u60c5，\u76f8\u5173\u7684\u662f\u96c6\u5408
\n collection_path = re.match(r'^(\/api\/[^\/]+)\/\\\\d+$', path).group(1)
\n related.append({
\n "relation": "collection",
\n "path": collection_path,
\n "methods": ["GET", "POST"]
\n })<\/p>\n
return related<\/p>\n
# \u96c6\u6210OPTIONS\u5904\u7406\u5668
\noptions_handler = OptionsHandler(app)<\/p>\n
@app.route('\/api\/<path:path>', methods=['OPTIONS'])
\ndef handle_options(path):
\n """\u5904\u7406\u6240\u6709API\u7aef\u70b9\u7684OPTIONS\u8bf7\u6c42"""
\n full_path = f'\/api\/{path}'<\/p>\n
# \u67e5\u627e\u5339\u914d\u7684\u7aef\u70b9
\n adapter = app.url_map.bind('localhost')
\n try:
\n endpoint, values = adapter.match(full_path, method='OPTIONS')
\n except:
\n # \u6ca1\u6709\u627e\u5230\u5339\u914d\u7684\u7aef\u70b9
\n return jsonify({
\n "error": "Endpoint not found",
\n "path": full_path
\n }), 404<\/p>\n
# \u751f\u6210OPTIONS\u54cd\u5e94
\n response_data = options_handler.generate_options_response(endpoint, full_path)<\/p>\n
# \u6dfb\u52a0\u5fc5\u8981\u7684\u5934\u90e8
\n response = jsonify(response_data)
\n response.headers['Allow'] = ', '.join(response_data['allowed_methods'])
\n response.headers['Access-Control-Allow-Methods'] = ', '.join(response_data['allowed_methods'])
\n response.headers['Access-Control-Allow-Headers'] = 'Content-Type, Authorization'
\n response.headers['Access-Control-Max-Age'] = '86400' # 24\u5c0f\u65f6<\/p>\n
return response<\/p>\n
javascript<\/p>\n
\/\/ \u5ba2\u6237\u7aef\u65b9\u6cd5\u53d1\u73b0\u548c\u9002\u914d\u7cfb\u7edf
\nclass MethodDiscoveryClient {
\n constructor(baseURL, options = {}) {
\n this.baseURL = baseURL;
\n this.options = {
\n cacheDuration: 5 * 60 * 1000, \/\/ 5\u5206\u949f
\n autoDiscover: true,
\n maxRetries: 2,
\n …options
\n };<\/p>\n
this.methodCache = new Map(); \/\/ \u7f13\u5b58\u7aef\u70b9\u652f\u6301\u7684\u65b9\u6cd5
\n this.schemaCache = new Map(); \/\/ \u7f13\u5b58\u7aef\u70b9\u6a21\u5f0f
\n this.fallbackStrategies = new Map(); \/\/ \u5907\u7528\u7b56\u7565
\n }<\/p>\n
async discoverMethods(endpoint) {
\n """\u53d1\u73b0\u7aef\u70b9\u652f\u6301\u7684\u65b9\u6cd5"""<\/p>\n
\/\/ \u68c0\u67e5\u7f13\u5b58
\n const cached = this.getCachedMethods(endpoint);
\n if (cached) {
\n return cached;
\n }<\/p>\n
try {
\n \/\/ \u53d1\u9001OPTIONS\u8bf7\u6c42
\n const response = await this.sendOptionsRequest(endpoint);<\/p>\n
if (response.status === 200) {
\n const data = await response.json();<\/p>\n
\/\/ \u89e3\u6790\u5141\u8bb8\u7684\u65b9\u6cd5
\n const allowedMethods = this.parseAllowedMethods(response, data);<\/p>\n
\/\/ \u7f13\u5b58\u7ed3\u679c
\n this.cacheMethods(endpoint, allowedMethods, data);<\/p>\n
return {
\n success: true,
\n methods: allowedMethods,
\n documentation: data
\n };
\n }<\/p>\n
return {
\n success: false,
\n error: `OPTIONS request failed with status ${response.status}`,
\n methods: this.getDefaultMethods(endpoint)
\n };<\/p>\n
} catch (error) {
\n console.warn(`Method discovery failed for ${endpoint}:`, error);<\/p>\n
return {
\n success: false,
\n error: error.message,
\n methods: this.getDefaultMethods(endpoint)
\n };
\n }
\n }<\/p>\n
parseAllowedMethods(response, data) {
\n """\u89e3\u6790\u5141\u8bb8\u7684\u65b9\u6cd5"""
\n const methods = new Set();<\/p>\n
\/\/ \u4eceAllow\u5934\u89e3\u6790
\n const allowHeader = response.headers.get('Allow');
\n if (allowHeader) {
\n allowHeader.split(',').forEach(method => {
\n methods.add(method.trim());
\n });
\n }<\/p>\n
\/\/ \u4ece\u54cd\u5e94\u4f53\u89e3\u6790
\n if (data && data.allowed_methods) {
\n data.allowed_methods.forEach(method => methods.add(method));
\n }<\/p>\n
return Array.from(methods);
\n }<\/p>\n
async requestWithDiscovery(endpoint, options = {}) {
\n """\u5e26\u6709\u65b9\u6cd5\u53d1\u73b0\u7684\u8bf7\u6c42"""
\n const { method, …restOptions } = options;<\/p>\n
\/\/ 1. \u53d1\u73b0\u7aef\u70b9\u652f\u6301\u7684\u65b9\u6cd5
\n const discovery = await this.discoverMethods(endpoint);<\/p>\n
\/\/ 2. \u68c0\u67e5\u8bf7\u6c42\u65b9\u6cd5\u662f\u5426\u5141\u8bb8
\n if (discovery.methods && !discovery.methods.includes(method)) {
\n \/\/ \u65b9\u6cd5\u4e0d\u5141\u8bb8，\u5c1d\u8bd5\u627e\u5230\u66ff\u4ee3\u65b9\u6cd5
\n const alternative = this.findAlternativeMethod(method, discovery.methods, endpoint);<\/p>\n
if (alternative) {
\n console.log(`Method ${method} not allowed. Using alternative: ${alternative.method}`);<\/p>\n
\/\/ \u8c03\u6574\u8bf7\u6c42
\n const adjustedOptions = this.adjustRequestForAlternative(
\n method,
\n alternative.method,
\n restOptions
\n );<\/p>\n
return this.fetchWithRetry(endpoint, {
\n method: alternative.method,
\n …adjustedOptions
\n });
\n }<\/p>\n
\/\/ \u6ca1\u6709\u627e\u5230\u66ff\u4ee3\u65b9\u6cd5，\u629b\u51fa\u9519\u8bef
\n throw new MethodNotAllowedError(endpoint, method, discovery.methods);
\n }<\/p>\n
\/\/ 3. \u6267\u884c\u8bf7\u6c42
\n return this.fetchWithRetry(endpoint, options);
\n }<\/p>\n
findAlternativeMethod(requestedMethod, allowedMethods, endpoint) {
\n """\u67e5\u627e\u66ff\u4ee3\u65b9\u6cd5"""<\/p>\n
\/\/ \u9884\u5b9a\u4e49\u7684\u66ff\u4ee3\u7b56\u7565
\n const alternativeStrategies = {
\n 'PUT': {
\n alternatives: ['PATCH', 'POST'],
\n conditions: {
\n 'PATCH': (endpoint) => endpoint.includes('\/api\/'), \/\/ \u53ea\u5bf9API\u7aef\u70b9
\n 'POST': (endpoint) => !endpoint.match(\/\\\\\/\\\\d+$\/) \/\/ \u4e0d\u5bf9\u8d44\u6e90ID\u7aef\u70b9
\n }
\n },
\n 'PATCH': {
\n alternatives: ['PUT'],
\n conditions: {
\n 'PUT': (endpoint) => true
\n }
\n },
\n 'DELETE': {
\n alternatives: ['POST'],
\n conditions: {
\n 'POST': (endpoint) => endpoint.includes('\/delete') \/\/ \u7279\u6b8a\u5220\u9664\u7aef\u70b9
\n }
\n }
\n };<\/p>\n
const strategy = alternativeStrategies[requestedMethod];
\n if (!strategy) return null;<\/p>\n
for (const alternative of strategy.alternatives) {
\n if (allowedMethods.includes(alternative)) {
\n const condition = strategy.conditions[alternative];
\n if (!condition || condition(endpoint)) {
\n return {
\n method: alternative,
\n reason: `Suggested alternative for ${requestedMethod}`
\n };
\n }
\n }
\n }<\/p>\n
return null;
\n }<\/p>\n
adjustRequestForAlternative(originalMethod, alternativeMethod, options) {
\n """\u4e3a\u66ff\u4ee3\u65b9\u6cd5\u8c03\u6574\u8bf7\u6c42"""
\n const adjusted = { …options };<\/p>\n
\/\/ \u7279\u6b8a\u8c03\u6574
\n if (originalMethod === 'PUT' && alternativeMethod === 'PATCH') {
\n \/\/ PUT -> PATCH: \u53ef\u80fd\u9700\u8981\u8c03\u6574\u8bf7\u6c42\u4f53
\n if (adjusted.headers) {
\n adjusted.headers['X-Original-Method'] = 'PUT';
\n }
\n }<\/p>\n
if (originalMethod === 'DELETE' && alternativeMethod === 'POST') {
\n \/\/ DELETE -> POST: \u6dfb\u52a0\u5220\u9664\u6307\u793a\u5668
\n if (adjusted.body) {
\n const body = JSON.parse(adjusted.body);
\n adjusted.body = JSON.stringify({
\n …body,
\n _action: 'delete'
\n });
\n }
\n }<\/p>\n
return adjusted;
\n }<\/p>\n
async fetchWithRetry(endpoint, options, retryCount = 0) {
\n """\u5e26\u91cd\u8bd5\u7684fetch"""
\n try {
\n const response = await fetch(`${this.baseURL}${endpoint}`, options);<\/p>\n
\/\/ \u5904\u7406405\u54cd\u5e94（\u5373\u4f7f\u5df2\u7ecf\u68c0\u67e5\u8fc7）
\n if (response.status === 405) {
\n if (retryCount < this.options.maxRetries) {
\n \/\/ \u6e05\u9664\u7f13\u5b58\u5e76\u91cd\u8bd5
\n this.clearCache(endpoint);
\n return this.requestWithDiscovery(endpoint, options);
\n }
\n }<\/p>\n
return response;<\/p>\n
} catch (error) {
\n if (retryCount < this.options.maxRetries) {
\n \/\/ \u6307\u6570\u9000\u907f
\n const delay = Math.pow(2, retryCount) * 1000;
\n await this.sleep(delay);
\n return this.fetchWithRetry(endpoint, options, retryCount + 1);
\n }
\n throw error;
\n }
\n }<\/p>\n
getCachedMethods(endpoint) {
\n """\u83b7\u53d6\u7f13\u5b58\u7684\u65b9\u6cd5"""
\n const cacheEntry = this.methodCache.get(endpoint);
\n if (cacheEntry && Date.now() – cacheEntry.timestamp < this.options.cacheDuration) {
\n return cacheEntry.data;
\n }
\n return null;
\n }<\/p>\n
cacheMethods(endpoint, methods, documentation) {
\n """\u7f13\u5b58\u65b9\u6cd5"""
\n this.methodCache.set(endpoint, {
\n timestamp: Date.now(),
\n data: { methods, documentation }
\n });
\n }<\/p>\n
clearCache(endpoint = null) {
\n """\u6e05\u9664\u7f13\u5b58"""
\n if (endpoint) {
\n this.methodCache.delete(endpoint);
\n } else {
\n this.methodCache.clear();
\n }
\n }<\/p>\n
getDefaultMethods(endpoint) {
\n """\u83b7\u53d6\u9ed8\u8ba4\u65b9\u6cd5"""
\n \/\/ \u57fa\u4e8e\u7aef\u70b9\u6a21\u5f0f\u63a8\u65ad
\n if (endpoint.match(\/\\\\\/\\\\d+$\/)) {
\n return ['GET', 'PUT', 'PATCH', 'DELETE']; \/\/ \u8d44\u6e90\u7aef\u70b9
\n } else {
\n return ['GET', 'POST']; \/\/ \u96c6\u5408\u7aef\u70b9
\n }
\n }<\/p>\n
sleep(ms) {
\n return new Promise(resolve => setTimeout(resolve, ms));
\n }
\n}<\/p>\n
class MethodNotAllowedError extends Error {
\n constructor(endpoint, method, allowedMethods) {
\n super(`Method ${method} not allowed for ${endpoint}`);
\n this.name = 'MethodNotAllowedError';
\n this.endpoint = endpoint;
\n this.method = method;
\n this.allowedMethods = allowedMethods;
\n }
\n}<\/p>\n
\/\/ \u4f7f\u7528\u793a\u4f8b
\nconst client = new MethodDiscoveryClient('https:\/\/api.example.com');<\/p>\n
\/\/ \u667a\u80fd\u8bf7\u6c42
\nasync function updateUser(userId, data) {
\n try {
\n const response = await client.requestWithDiscovery(`\/api\/users\/${userId}`, {
\n method: 'PUT', \/\/ \u53ef\u80fd\u81ea\u52a8\u8f6c\u4e3aPATCH
\n headers: {
\n 'Content-Type': 'application\/json',
\n 'Authorization': `Bearer ${token}`
\n },
\n body: JSON.stringify(data)
\n });<\/p>\n
if (!response.ok) {
\n throw new Error(`Request failed: ${response.status}`);
\n }<\/p>\n
return await response.json();<\/p>\n
} catch (error) {
\n if (error.name === 'MethodNotAllowedError') {
\n \/\/ \u663e\u793a\u7528\u6237\u53cb\u597d\u7684\u9519\u8bef
\n showMethodErrorUI(error);
\n return null;
\n }
\n throw error;
\n }
\n}<\/p>\n
\/\/ UI\u7ec4\u4ef6：\u663e\u793a\u65b9\u6cd5\u9519\u8bef
\nfunction showMethodErrorUI(error) {
\n const container = document.getElementById('error-container');<\/p>\n
const html = `
\n <div class="method-error">
\n <h3>\u274c Operation Not Supported<\/h3>
\n <p>The requested operation (<code>${error.method}<\/code>) is not supported for this resource.<\/p><\/p>\n
<div class="allowed-methods">
\n <h4>Supported Operations:<\/h4>
\n <ul>
\n ${error.allowedMethods.map(method => `
\n <li>
\n <code>${method}<\/code>
\n <span class="method-description">${getMethodDescription(method)}<\/span>
\n <\/li>
\n `).join('')}
\n <\/ul>
\n <\/div><\/p>\n
<div class="actions">
\n <button \u03bfnclick="retryWithGet()">View Resource<\/button>
\n <button \u03bfnclick="showAlternativeOptions()">Other Options<\/button>
\n <button \u03bfnclick="dismissError()">Dismiss<\/button>
\n <\/div>
\n <\/div>
\n `;<\/p>\n
container.innerHTML = html;
\n}<\/p>\n
function getMethodDescription(method) {
\n const descriptions = {
\n 'GET': 'Retrieve data',
\n 'POST': 'Create new resource',
\n 'PUT': 'Replace entire resource',
\n 'PATCH': 'Update partial resource',
\n 'DELETE': 'Remove resource',
\n 'OPTIONS': 'Get supported methods'
\n };
\n return descriptions[method] || '';
\n}<\/p>\n
python<\/p>\n
# 405\u9519\u8bef\u76d1\u63a7\u4e0e\u5206\u6790
\nfrom datetime import datetime, timedelta
\nfrom collections import defaultdict, Counter
\nimport json
\nfrom typing import Dict, List, Any
\nfrom dataclasses import dataclass, asdict
\nimport re<\/p>\n
@dataclass
\nclass MethodNotAllowedEvent:
\n timestamp: datetime
\n endpoint: str
\n attempted_method: str
\n allowed_methods: List[str]
\n client_ip: str
\n user_agent: str
\n referer: str
\n api_version: str = None
\n user_id: str = None
\n request_body_preview: str = None<\/p>\n
def to_dict(self):
\n data = asdict(self)
\n data['timestamp'] = self.timestamp.isoformat()
\n return data<\/p>\n
class MethodNotAllowedAnalyzer:
\n def __init__(self):
\n self.events = []
\n self.patterns = defaultdict(lambda: {
\n 'total': 0,
\n 'by_method': Counter(),
\n 'by_client': Counter(),
\n 'by_api_version': Counter(),
\n 'first_seen': None,
\n 'last_seen': None
\n })<\/p>\n
# \u5e38\u89c1\u9519\u8bef\u6a21\u5f0f\u68c0\u6d4b\u5668
\n self.error_patterns = {
\n 'collection_put': re.compile(r'^\/api\/([^\/]+)$'),
\n 'resource_post': re.compile(r'^\/api\/([^\/]+)\/\\\\d+$'),
\n 'incorrect_http_method': re.compile(r'PUT|POST|PATCH|DELETE', re.I),
\n 'legacy_api': re.compile(r'\/v1\/|\/legacy\/'),
\n }<\/p>\n
def record_event(self, event: MethodNotAllowedEvent):
\n """\u8bb0\u5f55405\u4e8b\u4ef6"""
\n self.events.append(event)<\/p>\n
# \u66f4\u65b0\u6a21\u5f0f\u7edf\u8ba1
\n pattern = self.categorize_endpoint(event.endpoint)
\n pattern_data = self.patterns[pattern]<\/p>\n
pattern_data['total'] += 1
\n pattern_data['by_method'][event.attempted_method] += 1
\n pattern_data['by_client'][event.client_ip] += 1
\n if event.api_version:
\n pattern_data['by_api_version'][event.api_version] += 1<\/p>\n
pattern_data['last_seen'] = event.timestamp
\n if not pattern_data['first_seen']:
\n pattern_data['first_seen'] = event.timestamp<\/p>\n
# \u5b9e\u65f6\u5206\u6790
\n self.realtime_analysis(event)<\/p>\n
# \u6301\u4e45\u5316
\n self.persist_event(event)<\/p>\n
# \u68c0\u67e5\u662f\u5426\u9700\u8981\u8b66\u62a5
\n self.check_for_alerts(event, pattern_data)<\/p>\n
def categorize_endpoint(self, endpoint: str) -> str:
\n """\u5bf9\u7aef\u70b9\u8fdb\u884c\u5206\u7c7b"""
\n # \u63d0\u53d6\u6a21\u5f0f：\u5c06ID\u7b49\u66ff\u6362\u4e3a\u5360\u4f4d\u7b26
\n pattern = re.sub(r'\/\\\\d+', '\/{id}', endpoint)
\n pattern = re.sub(r'\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}', '\/{uuid}', pattern, flags=re.I)
\n pattern = re.sub(r'\/[a-f0-9]{32}', '\/{hash}', pattern)<\/p>\n
return pattern<\/p>\n
def realtime_analysis(self, event: MethodNotAllowedEvent):
\n """\u5b9e\u65f6\u5206\u6790405\u4e8b\u4ef6"""
\n insights = []<\/p>\n
# 1. \u68c0\u6d4b\u5e38\u89c1RESTful\u9519\u8bef
\n if self.error_patterns['collection_put'].match(event.endpoint) and event.attempted_method == 'PUT':
\n insights.append({
\n 'type': 'collection_put_error',
\n 'message': 'PUT method used on collection endpoint',
\n 'suggestion': 'Use POST for creating resources in collections'
\n })<\/p>\n
if self.error_patterns['resource_post'].match(event.endpoint) and event.attempted_method == 'POST':
\n insights.append({
\n 'type': 'resource_post_error',
\n 'message': 'POST method used on resource endpoint',
\n 'suggestion': 'Use PUT or PATCH for updating existing resources'
\n })<\/p>\n
# 2. \u68c0\u6d4bAPI\u7248\u672c\u95ee\u9898
\n if self.error_patterns['legacy_api'].search(event.endpoint):
\n insights.append({
\n 'type': 'legacy_api_access',
\n 'message': 'Access to legacy API version',
\n 'suggestion': 'Migrate to newer API version'
\n })<\/p>\n
# 3. \u68c0\u6d4b\u53ef\u80fd\u7684\u6076\u610f\u626b\u63cf
\n if self.is_scanning_attempt(event):
\n insights.append({
\n 'type': 'possible_scanning',
\n 'message': 'Possible scanning attempt detected',
\n 'severity': 'high'
\n })<\/p>\n
# \u8bb0\u5f55\u6d1e\u5bdf
\n if insights:
\n self.record_insights(event, insights)<\/p>\n
def is_scanning_attempt(self, event: MethodNotAllowedEvent) -> bool:
\n """\u68c0\u6d4b\u662f\u5426\u662f\u626b\u63cf\u5c1d\u8bd5"""
\n # \u68c0\u67e5\u77ed\u65f6\u95f4\u5185\u591a\u79cd\u65b9\u6cd5\u5c1d\u8bd5
\n recent_events = self.get_recent_events(event.client_ip, minutes=5)<\/p>\n
if len(recent_events) > 10:
\n # \u77ed\u65f6\u95f4\u5185\u5927\u91cf405\u9519\u8bef
\n return True<\/p>\n
# \u68c0\u67e5\u662f\u5426\u5c1d\u8bd5\u4e86\u5371\u9669\u65b9\u6cd5
\n dangerous_methods = ['CONNECT', 'TRACE']
\n if event.attempted_method in dangerous_methods:
\n return True<\/p>\n
# \u68c0\u67e5\u662f\u5426\u5c1d\u8bd5\u4e86\u591a\u79cd\u65b9\u6cd5
\n unique_methods = set(e.attempted_method for e in recent_events)
\n if len(unique_methods) > 5:
\n return True<\/p>\n
return False<\/p>\n
def get_recent_events(self, client_ip: str, minutes: int = 5) -> List[MethodNotAllowedEvent]:
\n """\u83b7\u53d6\u5ba2\u6237\u7aef\u6700\u8fd1\u7684405\u4e8b\u4ef6"""
\n cutoff = datetime.utcnow() – timedelta(minutes=minutes)
\n return [
\n e for e in self.events
\n if e.client_ip == client_ip and e.timestamp > cutoff
\n ]<\/p>\n
def check_for_alerts(self, event: MethodNotAllowedEvent, pattern_data: Dict):
\n """\u68c0\u67e5\u662f\u5426\u9700\u8981\u53d1\u9001\u8b66\u62a5"""<\/p>\n
# 1. \u9ad8\u9891405\u6a21\u5f0f\u8b66\u62a5
\n if pattern_data['total'] > 100:
\n self.send_alert({
\n 'type': 'high_frequency_405',
\n 'pattern': event.endpoint,
\n 'count': pattern_data['total'],
\n 'timestamp': datetime.utcnow().isoformat(),
\n 'severity': 'medium'
\n })<\/p>\n
# 2. \u5ba2\u6237\u7aef\u5f02\u5e38\u884c\u4e3a\u8b66\u62a5
\n if pattern_data['by_client'][event.client_ip] > 20:
\n self.send_alert({
\n 'type': 'client_405_abuse',
\n 'client_ip': event.client_ip,
\n 'count': pattern_data['by_client'][event.client_ip],
\n 'timestamp': datetime.utcnow().isoformat(),
\n 'severity': 'high'
\n })<\/p>\n
# 3. API\u7248\u672c\u5f03\u7528\u8b66\u62a5
\n if event.api_version and 'v1' in event.api_version:
\n self.send_alert({
\n 'type': 'legacy_api_usage',
\n 'endpoint': event.endpoint,
\n 'api_version': event.api_version,
\n 'method': event.attempted_method,
\n 'timestamp': datetime.utcnow().isoformat(),
\n 'severity': 'low'
\n })<\/p>\n
def generate_report(self, period: str = '24h') -> Dict[str, Any]:
\n """\u751f\u6210405\u5206\u6790\u62a5\u544a"""
\n if period == '24h':
\n cutoff = datetime.utcnow() – timedelta(hours=24)
\n elif period == '7d':
\n cutoff = datetime.utcnow() – timedelta(days=7)
\n elif period == '30d':
\n cutoff = datetime.utcnow() – timedelta(days=30)
\n else:
\n cutoff = datetime.utcnow() – timedelta(hours=24)<\/p>\n
period_events = [e for e in self.events if e.timestamp > cutoff]<\/p>\n
report = {
\n 'period': period,
\n 'time_range': {
\n 'start': cutoff.isoformat(),
\n 'end': datetime.utcnow().isoformat()
\n },
\n 'summary': {
\n 'total_405s': len(period_events),
\n 'unique_endpoints': len(set(e.endpoint for e in period_events)),
\n 'unique_clients': len(set(e.client_ip for e in period_events)),
\n 'methods_attempted': list(set(e.attempted_method for e in period_events))
\n },
\n 'top_patterns': sorted(
\n [(pattern, data['total']) for pattern, data in self.patterns.items()],
\n key=lambda x: x[1],
\n reverse=True
\n )[:10],
\n 'top_methods': Counter(e.attempted_method for e in period_events).most_common(),
\n 'top_clients': Counter(e.client_ip for e in period_events).most_common(10),
\n 'hourly_distribution': self.get_hourly_distribution(period_events),
\n 'insights': self.generate_insights(period_events)
\n }<\/p>\n
return report<\/p>\n
def get_hourly_distribution(self, events: List[MethodNotAllowedEvent]) -> Dict[str, int]:
\n """\u83b7\u53d6\u6309\u5c0f\u65f6\u5206\u5e03"""
\n distribution = defaultdict(int)
\n for event in events:
\n hour = event.timestamp.strftime('%H:00')
\n distribution[hour] += 1
\n return dict(sorted(distribution.items()))<\/p>\n
def generate_insights(self, events: List[MethodNotAllowedEvent]) -> List[Dict]:
\n """\u751f\u6210\u6d1e\u5bdf\u548c\u5efa\u8bae"""
\n insights = []<\/p>\n
if not events:
\n return insights<\/p>\n
# \u6309\u7aef\u70b9\u5206\u7ec4
\n endpoint_groups = defaultdict(list)
\n for event in events:
\n endpoint_groups[event.endpoint].append(event)<\/p>\n
# \u5206\u6790\u6bcf\u4e2a\u9891\u7e41\u51fa\u73b0405\u7684\u7aef\u70b9
\n for endpoint, endpoint_events in endpoint_groups.items():
\n if len(endpoint_events) > 5: # \u9608\u503c
\n insight = self.analyze_endpoint_pattern(endpoint, endpoint_events)
\n if insight:
\n insights.append(insight)<\/p>\n
# \u603b\u4f53\u6d1e\u5bdf
\n overall_insights = self.analyze_overall_patterns(events)
\n insights.extend(overall_insights)<\/p>\n
return insights[:20] # \u9650\u5236\u6570\u91cf<\/p>\n
def analyze_endpoint_pattern(self, endpoint: str, events: List[MethodNotAllowedEvent]) -> Dict:
\n """\u5206\u6790\u7279\u5b9a\u7aef\u70b9\u7684405\u6a21\u5f0f"""
\n methods_attempted = Counter(e.attempted_method for e in events)
\n clients = Counter(e.client_ip for e in events)<\/p>\n
insight = {
\n 'endpoint': endpoint,
\n 'total_attempts': len(events),
\n 'top_methods': methods_attempted.most_common(3),
\n 'unique_clients': len(clients),
\n 'suggestions': []
\n }<\/p>\n
# \u6839\u636e\u6a21\u5f0f\u751f\u6210\u5efa\u8bae
\n if re.match(r'^\/api\/([^\/]+)$', endpoint):
\n # \u96c6\u5408\u7aef\u70b9
\n if 'PUT' in methods_attempted:
\n insight['suggestions'].append(
\n 'Consider adding PUT support or clarifying documentation'
\n )<\/p>\n
elif re.match(r'^\/api\/([^\/]+)\/\\\\d+$', endpoint):
\n # \u8d44\u6e90\u7aef\u70b9
\n if 'POST' in methods_attempted:
\n insight['suggestions'].append(
\n 'Clients are trying to POST to resource endpoints. '
\n 'This might indicate confusion about RESTful conventions.'
\n )<\/p>\n
# \u5982\u679c\u6709\u5927\u91cf\u4e0d\u540c\u7684\u5ba2\u6237\u7aef\u51fa\u73b0\u76f8\u540c\u9519\u8bef
\n if len(clients) > 10:
\n insight['suggestions'].append(
\n 'Multiple clients are making the same error. '
\n 'Consider improving API documentation or client SDKs.'
\n )<\/p>\n
return insight if insight['suggestions'] else None<\/p>\n
def persist_event(self, event: MethodNotAllowedEvent):
\n """\u6301\u4e45\u5316\u4e8b\u4ef6\u5230\u6587\u4ef6"""
\n with open('405_method_errors.jsonl', 'a') as f:
\n f.write(json.dumps(event.to_dict()) + '\\\\n')<\/p>\n
def record_insights(self, event: MethodNotAllowedEvent, insights: List[Dict]):
\n """\u8bb0\u5f55\u6d1e\u5bdf"""
\n insight_record = {
\n 'timestamp': datetime.utcnow().isoformat(),
\n 'event': event.to_dict(),
\n 'insights': insights
\n }<\/p>\n
with open('405_insights.jsonl', 'a') as f:
\n f.write(json.dumps(insight_record) + '\\\\n')<\/p>\n
def send_alert(self, alert: Dict):
\n """\u53d1\u9001\u8b66\u62a5"""
\n # \u8fd9\u91cc\u53ef\u4ee5\u96c6\u6210\u5404\u79cd\u901a\u77e5\u7cfb\u7edf
\n print(f"[405 Alert] {json.dumps(alert)}")<\/p>\n
# \u8bb0\u5f55\u5230\u6587\u4ef6
\n with open('405_alerts.jsonl', 'a') as f:
\n f.write(json.dumps(alert) + '\\\\n')<\/p>\n
javascript<\/p>\n
\/\/ React\u7ec4\u4ef6：405\u76d1\u63a7\u4eea\u8868\u677f
\nimport React, { useState, useEffect } from 'react';
\nimport {
\n BarChart, Bar, LineChart, Line, PieChart, Pie, Cell,
\n XAxis, YAxis, CartesianGrid, Tooltip, Legend, ResponsiveContainer
\n} from 'recharts';<\/p>\n
function MethodNotAllowedDashboard() {
\n const [timeRange, setTimeRange] = useState('24h');
\n const [stats, setStats] = useState(null);
\n const [realtimeEvents, setRealtimeEvents] = useState([]);
\n const [topPatterns, setTopPatterns] = useState([]);<\/p>\n
\/\/ \u83b7\u53d6\u7edf\u8ba1\u6570\u636e
\n useEffect(() => {
\n const fetchStats = async () => {
\n const response = await fetch(`\/api\/monitor\/405-stats?range=${timeRange}`);
\n const data = await response.json();
\n setStats(data);<\/p>\n
\/\/ \u5904\u7406\u6a21\u5f0f\u6570\u636e\u7528\u4e8e\u56fe\u8868
\n if (data.top_patterns) {
\n setTopPatterns(data.top_patterns.map(([pattern, count]) => ({
\n pattern,
\n count,
\n shortPattern: pattern.length > 30 ? pattern.substring(0, 30) + '…' : pattern
\n })));
\n }
\n };<\/p>\n
fetchStats();
\n const interval = setInterval(fetchStats, 60000); \/\/ \u6bcf\u5206\u949f\u66f4\u65b0<\/p>\n
return () => clearInterval(interval);
\n }, [timeRange]);<\/p>\n
\/\/ WebSocket\u8fde\u63a5\u63a5\u6536\u5b9e\u65f6\u4e8b\u4ef6
\n useEffect(() => {
\n const ws = new WebSocket('wss:\/\/api.example.com\/monitor\/405-events');<\/p>\n
ws.onmessage = (event) => {
\n const eventData = JSON.parse(event.data);<\/p>\n
setRealtimeEvents(prev => [
\n { …eventData, id: Date.now() },
\n …prev.slice(0, 49) \/\/ \u4fdd\u7559\u6700\u8fd150\u4e2a
\n ]);
\n };<\/p>\n
return () => ws.close();
\n }, []);<\/p>\n
if (!stats) {
\n return <div className="loading">\u52a0\u8f7d\u4e2d…<\/div>;
\n }<\/p>\n
return (
\n <div className="dashboard method-not-allowed-dashboard">
\n <div className="dashboard-header">
\n <h1>405 Method Not Allowed \u76d1\u63a7<\/h1>
\n <div className="time-range-selector">
\n {['1h', '24h', '7d', '30d'].map(range => (
\n <button
\n key={range}
\n className={timeRange === range ? 'active' : ''}
\n onClick={() => setTimeRange(range)}
\n >
\n \u8fc7\u53bb{range}
\n <\/button>
\n ))}
\n <\/div>
\n <\/div><\/p>\n
{\/* \u6982\u89c8\u5361\u7247 *\/}
\n <div className="overview-cards">
\n <div className="card total">
\n <h3>\u603b405\u9519\u8bef\u6570<\/h3>
\n <p className="value">{stats.summary.total_405s.toLocaleString()}<\/p>
\n <p className="trend">\u8fc7\u53bb24\u5c0f\u65f6<\/p>
\n <\/div><\/p>\n
<div className="card endpoints">
\n <h3>\u53d7\u5f71\u54cd\u7aef\u70b9<\/h3>
\n <p className="value">{stats.summary.unique_endpoints}<\/p>
\n <p className="trend">{topPatterns.length} \u4e2a\u4e3b\u8981\u6a21\u5f0f<\/p>
\n <\/div><\/p>\n
<div className="card clients">
\n <h3>\u5f71\u54cd\u7684\u5ba2\u6237\u7aef<\/h3>
\n <p className="value">{stats.summary.unique_clients}<\/p>
\n <p className="trend">{stats.top_clients?.[0]?.[1] || 0} \u6b21\u6765\u81ea\u6700\u6d3b\u8dc3\u5ba2\u6237\u7aef<\/p>
\n <\/div><\/p>\n
<div className="card methods">
\n <h3>\u9519\u8bef\u65b9\u6cd5<\/h3>
\n <p className="value">{stats.summary.methods_attempted.length}<\/p>
\n <p className="trend">
\n \u6700\u5e38\u89c1: {stats.top_methods?.[0]?.[0] || 'N\/A'}
\n <\/p>
\n <\/div>
\n <\/div><\/p>\n
{\/* \u56fe\u8868\u533a\u57df *\/}
\n <div className="charts-grid">
\n <div className="chart-container large">
\n <h3>405\u9519\u8bef\u8d8b\u52bf<\/h3>
\n <ResponsiveContainer width="100%" height={300}>
\n <LineChart data={stats.hourly_distribution ?
\n Object.entries(stats.hourly_distribution).map(([hour, count]) => ({ hour, count })) : []}>
\n <CartesianGrid strokeDasharray="3 3" \/>
\n <XAxis dataKey="hour" \/>
\n <YAxis \/>
\n <Tooltip \/>
\n <Legend \/>
\n <Line type="monotone" dataKey="count" stroke="#8884d8" name="405\u9519\u8bef\u6570" \/>
\n <\/LineChart>
\n <\/ResponsiveContainer>
\n <\/div><\/p>\n
<div className="chart-container">
\n <h3>\u9519\u8bef\u65b9\u6cd5\u5206\u5e03<\/h3>
\n <ResponsiveContainer width="100%" height={300}>
\n <PieChart>
\n <Pie
\n data={stats.top_methods?.map(([method, count]) => ({ method, count })) || []}
\n cx="50%"
\n cy="50%"
\n labelLine={false}
\n label={({ method, percent }) => `${method}: ${(percent * 100).toFixed(1)}%`}
\n outerRadius={80}
\n fill="#8884d8"
\n dataKey="count"
\n >
\n {stats.top_methods?.map((entry, index) => (
\n <Cell key={`cell-${index}`} fill={[
\n '#8884d8', '#82ca9d', '#ffc658',
\n '#ff7300', '#0088fe'
\n ][index % 5]} \/>
\n ))}
\n <\/Pie>
\n <Tooltip \/>
\n <\/PieChart>
\n <\/ResponsiveContainer>
\n <\/div><\/p>\n
<div className="chart-container large">
\n <h3>\u6700\u5e38\u89c1\u7aef\u70b9\u6a21\u5f0f<\/h3>
\n <ResponsiveContainer width="100%" height={400}>
\n <BarChart data={topPatterns.slice(0, 10)}>
\n <CartesianGrid strokeDasharray="3 3" \/>
\n <XAxis dataKey="shortPattern" angle={-45} textAnchor="end" height={80} \/>
\n <YAxis \/>
\n <Tooltip
\n formatter={(value, name, props) => [
\n value,
\n props.payload.pattern.length > 30 ?
\n `${props.payload.pattern.substring(0, 30)}…` :
\n props.payload.pattern
\n ]}
\n \/>
\n <Bar dataKey="count" fill="#82ca9d" name="\u9519\u8bef\u6b21\u6570" \/>
\n <\/BarChart>
\n <\/ResponsiveContainer>
\n <\/div><\/p>\n
<div className="chart-container">
\n <h3>\u5ba2\u6237\u7aef\u5206\u5e03<\/h3>
\n <ResponsiveContainer width="100%" height={300}>
\n <BarChart data={stats.top_clients?.slice(0, 5).map(([ip, count]) => ({ ip, count })) || []}>
\n <CartesianGrid strokeDasharray="3 3" \/>
\n <XAxis dataKey="ip" \/>
\n <YAxis \/>
\n <Tooltip \/>
\n <Bar dataKey="count" fill="#ffc658" name="\u9519\u8bef\u6b21\u6570" \/>
\n <\/BarChart>
\n <\/ResponsiveContainer>
\n <\/div>
\n <\/div><\/p>\n
{\/* \u5b9e\u65f6\u4e8b\u4ef6\u6d41 *\/}
\n <div className="realtime-events">
\n <h3>\u5b9e\u65f6405\u4e8b\u4ef6<\/h3>
\n <div className="events-table">
\n <table>
\n <thead>
\n <tr>
\n <th>\u65f6\u95f4<\/th>
\n <th>\u7aef\u70b9<\/th>
\n <th>\u5c1d\u8bd5\u7684\u65b9\u6cd5<\/th>
\n <th>\u5ba2\u6237\u7aefIP<\/th>
\n <th>\u5141\u8bb8\u7684\u65b9\u6cd5<\/th>
\n <\/tr>
\n <\/thead>
\n <tbody>
\n {realtimeEvents.map(event => (
\n <tr key={event.id} className="event-row">
\n <td>{new Date(event.timestamp).toLocaleTimeString()}<\/td>
\n <td className="endpoint-cell">
\n <code title={event.endpoint}>
\n {event.endpoint.length > 40 ?
\n event.endpoint.substring(0, 40) + '…' :
\n event.endpoint}
\n <\/code>
\n <\/td>
\n <td>
\n <span className={`method-badge method-${event.attempted_method.toLowerCase()}`}>
\n {event.attempted_method}
\n <\/span>
\n <\/td>
\n <td>
\n <code>{event.client_ip}<\/code>
\n {event.user_agent && (
\n <div className="user-agent-tooltip">
\n {event.user_agent}
\n <\/div>
\n )}
\n <\/td>
\n <td>
\n <div className="allowed-methods">
\n {event.allowed_methods?.map(method => (
\n <span key={method} className="method-tag">
\n {method}
\n <\/span>
\n ))}
\n <\/div>
\n <\/td>
\n <\/tr>
\n ))}
\n <\/tbody>
\n <\/table>
\n <\/div>
\n <\/div><\/p>\n
{\/* \u6d1e\u5bdf\u548c\u5efa\u8bae *\/}
\n {stats.insights && stats.insights.length > 0 && (
\n <div className="insights-section">
\n <h3>\u6d1e\u5bdf\u548c\u5efa\u8bae<\/h3>
\n <div className="insights-list">
\n {stats.insights.map((insight, index) => (
\n <div key={index} className="insight-card">
\n <h4>\u7aef\u70b9\u6a21\u5f0f: {insight.endpoint}<\/h4>
\n <div className="insight-details">
\n <p><strong>\u603b\u9519\u8bef\u6570:<\/strong> {insight.total_attempts}<\/p>
\n <p><strong>\u5f71\u54cd\u5ba2\u6237\u7aef:<\/strong> {insight.unique_clients}<\/p>
\n <div className="top-methods">
\n <strong>\u5e38\u89c1\u9519\u8bef\u65b9\u6cd5:<\/strong>
\n <div className="method-list">
\n {insight.top_methods?.map(([method, count]) => (
\n <span key={method} className="method-with-count">
\n {method} ({count})
\n <\/span>
\n ))}
\n <\/div>
\n <\/div>
\n {insight.suggestions && insight.suggestions.length > 0 && (
\n <div className="suggestions">
\n <strong>\u5efa\u8bae:<\/strong>
\n <ul>
\n {insight.suggestions.map((suggestion, i) => (
\n <li key={i}>{suggestion}<\/li>
\n ))}
\n <\/ul>
\n <\/div>
\n )}
\n <\/div>
\n <\/div>
\n ))}
\n <\/div>
\n <\/div>
\n )}<\/p>\n
{\/* \u5bfc\u51fa\u548c\u64cd\u4f5c *\/}
\n <div className="actions-section">
\n <button
\n className="btn btn-primary"
\n onClick={() => window.open('\/api\/monitor\/405-report\/export?format=csv')}
\n >
\n \u5bfc\u51faCSV\u62a5\u544a
\n <\/button>
\n <button
\n className="btn btn-secondary"
\n onClick={() => window.open('\/api\/monitor\/405-report\/details')}
\n >
\n \u67e5\u770b\u8be6\u7ec6\u62a5\u544a
\n <\/button>
\n <button
\n className="btn btn-tertiary"
\n onClick={() => refreshDashboard()}
\n >
\n \u5237\u65b0\u6570\u636e
\n <\/button>
\n <\/div>
\n <\/div>
\n );
\n}<\/p>\n
python<\/p>\n
# \u9632\u6b62HTTP\u65b9\u6cd5\u679a\u4e3e\u653b\u51fb
\nclass MethodEnumerationProtection:
\n def __init__(self, config=None):
\n self.config = config or {
\n 'max_attempts_per_ip': 50, # \u6bcf\u4e2aIP\u6700\u5927\u5c1d\u8bd5\u6b21\u6570
\n 'time_window_minutes': 5, # \u65f6\u95f4\u7a97\u53e3
\n 'ban_duration_minutes': 30, # \u5c01\u7981\u65f6\u957f
\n 'sensitive_endpoints': [ # \u654f\u611f\u7aef\u70b9
\n '\/admin',
\n '\/api\/internal',
\n '\/debug',
\n '\/config'
\n ]
\n }<\/p>\n
self.attempt_tracker = defaultdict(list)
\n self.banned_ips = {}
\n self.suspicious_patterns = [
\n r'\\\\.(php|asp|jsp|aspx)$', # \u811a\u672c\u6587\u4ef6
\n r'\/(bin|etc|usr|var|opt)\/', # \u7cfb\u7edf\u76ee\u5f55
\n r'\\\\.(bak|old|backup|tar|gz)$', # \u5907\u4efd\u6587\u4ef6
\n ]<\/p>\n
def check_request(self, request):
\n """\u68c0\u67e5\u8bf7\u6c42，\u9632\u6b62\u65b9\u6cd5\u679a\u4e3e\u653b\u51fb"""
\n client_ip = request.remote_addr
\n path = request.path
\n method = request.method<\/p>\n
# 1. \u68c0\u67e5\u662f\u5426\u88ab\u5c01\u7981
\n if self.is_banned(client_ip):
\n return {
\n 'allowed': False,
\n 'reason': 'IP temporarily banned',
\n 'status': 429
\n }<\/p>\n
# 2. \u68c0\u67e5\u662f\u5426\u662f\u654f\u611f\u7aef\u70b9
\n if self.is_sensitive_endpoint(path):
\n # \u5bf9\u654f\u611f\u7aef\u70b9\u8fdb\u884c\u66f4\u4e25\u683c\u7684\u68c0\u67e5
\n if not self.validate_sensitive_access(client_ip, path, method):
\n return {
\n 'allowed': False,
\n 'reason': 'Sensitive endpoint access denied',
\n 'status': 403
\n }<\/p>\n
# 3. \u68c0\u67e5\u65b9\u6cd5\u679a\u4e3e\u5c1d\u8bd5
\n if self.is_method_enumeration(client_ip, path, method):
\n self.record_suspicious_activity(client_ip, 'method_enumeration', {
\n 'path': path,
\n 'method': method,
\n 'timestamp': datetime.utcnow().isoformat()
\n })<\/p>\n
# \u89e6\u53d1\u4fdd\u62a4
\n self.ban_ip(client_ip)<\/p>\n
return {
\n 'allowed': False,
\n 'reason': 'Method enumeration detected',
\n 'status': 429
\n }<\/p>\n
# 4. \u68c0\u67e5\u53ef\u7591\u8def\u5f84\u6a21\u5f0f
\n if self.is_suspicious_path(path):
\n self.record_suspicious_activity(client_ip, 'suspicious_path', {
\n 'path': path,
\n 'method': method,
\n 'timestamp': datetime.utcnow().isoformat()
\n })<\/p>\n
# \u8fd4\u56de\u7b80\u5316\u7684405\u54cd\u5e94，\u4e0d\u6cc4\u9732\u4fe1\u606f
\n return {
\n 'allowed': False,
\n 'reason': 'Suspicious request',
\n 'status': 404, # \u6545\u610f\u8fd4\u56de404\u800c\u4e0d\u662f405
\n 'simplified_response': True
\n }<\/p>\n
return {'allowed': True}<\/p>\n
def is_banned(self, client_ip):
\n """\u68c0\u67e5IP\u662f\u5426\u88ab\u5c01\u7981"""
\n if client_ip in self.banned_ips:
\n ban_time = self.banned_ips[client_ip]
\n ban_duration = timedelta(minutes=self.config['ban_duration_minutes'])<\/p>\n
if datetime.utcnow() – ban_time < ban_duration:
\n return True
\n else:
\n # \u5c01\u7981\u8fc7\u671f
\n del self.banned_ips[client_ip]<\/p>\n
return False<\/p>\n
def ban_ip(self, client_ip):
\n """\u5c01\u7981IP"""
\n self.banned_ips[client_ip] = datetime.utcnow()<\/p>\n
# \u8bb0\u5f55\u5b89\u5168\u4e8b\u4ef6
\n self.log_security_event('ip_banned', {
\n 'client_ip': client_ip,
\n 'reason': 'Method enumeration',
\n 'timestamp': datetime.utcnow().isoformat(),
\n 'duration_minutes': self.config['ban_duration_minutes']
\n })<\/p>\n
def is_sensitive_endpoint(self, path):
\n """\u68c0\u67e5\u662f\u5426\u662f\u654f\u611f\u7aef\u70b9"""
\n path_lower = path.lower()
\n return any(ep in path_lower for ep in self.config['sensitive_endpoints'])<\/p>\n
def validate_sensitive_access(self, client_ip, path, method):
\n """\u9a8c\u8bc1\u5bf9\u654f\u611f\u7aef\u70b9\u7684\u8bbf\u95ee"""
\n # \u8fd9\u91cc\u53ef\u4ee5\u5b9e\u73b0\u66f4\u590d\u6742\u7684\u903b\u8f91，\u5982：
\n # – \u68c0\u67e5\u767d\u540d\u5355
\n # – \u9a8c\u8bc1API\u5bc6\u94a5
\n # – \u68c0\u67e5\u5730\u7406\u4f4d\u7f6e<\/p>\n
# \u7b80\u5355\u793a\u4f8b：\u53ea\u5141\u8bb8GET\u548cOPTIONS\u65b9\u6cd5
\n allowed_methods = {'GET', 'OPTIONS'}
\n return method in allowed_methods<\/p>\n
def is_method_enumeration(self, client_ip, path, method):
\n """\u68c0\u67e5\u662f\u5426\u662f\u65b9\u6cd5\u679a\u4e3e\u5c1d\u8bd5"""
\n # \u8bb0\u5f55\u5c1d\u8bd5
\n key = f"{client_ip}:{path}"
\n self.attempt_tracker[key].append({
\n 'method': method,
\n 'timestamp': datetime.utcnow()
\n })<\/p>\n
# \u6e05\u7406\u65e7\u8bb0\u5f55
\n cutoff = datetime.utcnow() – timedelta(minutes=self.config['time_window_minutes'])
\n self.attempt_tracker[key] = [
\n attempt for attempt in self.attempt_tracker[key]
\n if attempt['timestamp'] > cutoff
\n ]<\/p>\n
# \u68c0\u67e5\u5c1d\u8bd5\u6b21\u6570
\n if len(self.attempt_tracker[key]) > self.config['max_attempts_per_ip']:
\n return True<\/p>\n
# \u68c0\u67e5\u662f\u5426\u5c1d\u8bd5\u4e86\u591a\u79cd\u65b9\u6cd5
\n unique_methods = set(attempt['method'] for attempt in self.attempt_tracker[key])
\n if len(unique_methods) > 5: # \u5c1d\u8bd5\u4e865\u79cd\u4ee5\u4e0a\u4e0d\u540c\u65b9\u6cd5
\n return True<\/p>\n
# \u68c0\u67e5\u662f\u5426\u5c1d\u8bd5\u4e86\u5371\u9669\u65b9\u6cd5
\n dangerous_methods = {'CONNECT', 'TRACE'}
\n if any(attempt['method'] in dangerous_methods for attempt in self.attempt_tracker[key]):
\n return True<\/p>\n
return False<\/p>\n
def is_suspicious_path(self, path):
\n """\u68c0\u67e5\u662f\u5426\u662f\u53ef\u7591\u8def\u5f84"""
\n path_lower = path.lower()<\/p>\n
# \u68c0\u67e5\u53ef\u7591\u6a21\u5f0f
\n for pattern in self.suspicious_patterns:
\n if re.search(pattern, path_lower):
\n return True<\/p>\n
# \u68c0\u67e5\u8def\u5f84\u904d\u5386
\n if '..' in path or '%2e%2e' in path_lower:
\n return True<\/p>\n
# \u68c0\u67e5\u8fc7\u957f\u7684\u8def\u5f84
\n if len(path) > 500:
\n return True<\/p>\n
return False<\/p>\n
def secure_405_response(self, path, method, allowed_methods, request, simplified=False):
\n """\u751f\u6210\u5b89\u5168\u7684405\u54cd\u5e94"""
\n client_ip = request.remote_addr<\/p>\n
if simplified:
\n # \u7b80\u5316\u54cd\u5e94，\u4e0d\u6cc4\u9732\u4fe1\u606f
\n response = jsonify({
\n 'error': {
\n 'code': 'NOT_FOUND',
\n 'message': 'Resource not found'
\n }
\n })
\n response.status_code = 404
\n response.headers['Allow'] = 'GET, POST' # \u901a\u7528\u5217\u8868
\n else:
\n # \u6b63\u5e38405\u54cd\u5e94
\n response = jsonify({
\n 'error': {
\n 'code': 'METHOD_NOT_ALLOWED',
\n 'message': f'Method {method} not allowed'
\n }
\n })
\n response.status_code = 405
\n response.headers['Allow'] = ', '.join(allowed_methods)<\/p>\n
# \u6dfb\u52a0\u5b89\u5168\u5934\u90e8
\n response.headers['X-Content-Type-Options'] = 'nosniff'
\n response.headers['X-Frame-Options'] = 'DENY'<\/p>\n
# \u8bb0\u5f55\u8bbf\u95ee（\u5b89\u5168\u7248\u672c）
\n self.log_405_access(client_ip, path, method, simplified)<\/p>\n
return response<\/p>\n
def log_405_access(self, client_ip, path, method, simplified):
\n """\u8bb0\u5f55405\u8bbf\u95ee（\u5b89\u5168\u7248\u672c）"""
\n # \u8131\u654f\u5904\u7406
\n safe_path = self.sanitize_path(path)<\/p>\n
log_entry = {
\n 'timestamp': datetime.utcnow().isoformat(),
\n 'client_ip': client_ip[:8] + '…', # \u90e8\u5206\u9690\u85cfIP
\n 'path': safe_path,
\n 'method': method,
\n 'simplified_response': simplified
\n }<\/p>\n
with open('secure_405_logs.jsonl', 'a') as f:
\n f.write(json.dumps(log_entry) + '\\\\n')<\/p>\n
def sanitize_path(self, path):
\n """\u8131\u654f\u8def\u5f84，\u79fb\u9664\u654f\u611f\u4fe1\u606f"""
\n # \u79fb\u9664\u67e5\u8be2\u53c2\u6570
\n clean_path = path.split('?')[0]<\/p>\n
# \u66ff\u6362ID\u7b49\u654f\u611f\u4fe1\u606f
\n clean_path = re.sub(r'\/\\\\d+', '\/{id}', clean_path)
\n clean_path = re.sub(r'\/[a-f0-9]{32}', '\/{hash}', clean_path, flags=re.I)<\/p>\n
return clean_path<\/p>\n
def record_suspicious_activity(self, client_ip, activity_type, data):
\n """\u8bb0\u5f55\u53ef\u7591\u6d3b\u52a8"""
\n event = {
\n 'type': activity_type,
\n 'client_ip': client_ip,
\n 'data': data,
\n 'timestamp': datetime.utcnow().isoformat()
\n }<\/p>\n
with open('security_events.jsonl', 'a') as f:
\n f.write(json.dumps(event) + '\\\\n')<\/p>\n
# \u53d1\u9001\u8b66\u62a5
\n self.send_security_alert(event)<\/p>\n
def log_security_event(self, event_type, data):
\n """\u8bb0\u5f55\u5b89\u5168\u4e8b\u4ef6"""
\n event = {
\n 'type': event_type,
\n 'data': data,
\n 'timestamp': datetime.utcnow().isoformat()
\n }<\/p>\n
with open('security_logs.jsonl', 'a') as f:
\n f.write(json.dumps(event) + '\\\\n')<\/p>\n
def send_security_alert(self, event):
\n """\u53d1\u9001\u5b89\u5168\u8b66\u62a5"""
\n # \u8fd9\u91cc\u53ef\u4ee5\u96c6\u6210\u5404\u79cd\u901a\u77e5\u7cfb\u7edf
\n print(f"[Security Alert] {json.dumps(event)}")<\/p>\n
# \u793a\u4f8b：\u53d1\u9001\u5230Slack
\n if event['type'] in ['method_enumeration', 'ip_banned']:
\n self.send_slack_alert(event)<\/p>\n
# \u96c6\u6210\u4fdd\u62a4\u673a\u5236
\nprotection = MethodEnumerationProtection()<\/p>\n
@app.before_request
\ndef apply_method_protection():
\n """\u5e94\u7528\u65b9\u6cd5\u4fdd\u62a4"""
\n if request.method not in ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS']:
\n # \u4e0d\u5e38\u89c1\u7684\u65b9\u6cd5，\u7acb\u5373\u68c0\u67e5
\n result = protection.check_request(request)
\n if not result['allowed']:
\n if result.get('simplified_response'):
\n return protection.secure_405_response(
\n request.path, request.method, [], request, simplified=True
\n )
\n else:
\n return jsonify({'error': result['reason']}), result.get('status', 403)<\/p>\n
@app.errorhandler(405)
\ndef handle_405_with_protection(e):
\n """\u5e26\u4fdd\u62a4\u7684405\u5904\u7406"""
\n # \u5148\u8fdb\u884c\u5b89\u5168\u68c0\u67e5
\n result = protection.check_request(request)<\/p>\n
if not result['allowed'] and result.get('simplified_response'):
\n return protection.secure_405_response(
\n request.path, request.method, [], request, simplified=True
\n )<\/p>\n
# \u6b63\u5e38405\u5904\u7406
\n allowed_methods = method_manager.get_allowed_methods(request.endpoint)
\n return protection.secure_405_response(
\n request.path, request.method, allowed_methods, request, simplified=False
\n )<\/p>\n
python<\/p>\n
# \u9ad8\u6548\u7684\u65b9\u6cd5\u9a8c\u8bc1\u548c\u7f13\u5b58\u7cfb\u7edf
\nfrom functools import lru_cache
\nfrom typing import Set, Tuple
\nimport time
\nimport threading<\/p>\n
class OptimizedMethodValidator:
\n """\u4f18\u5316\u7684\u65b9\u6cd5\u9a8c\u8bc1\u5668，\u5e26\u7f13\u5b58\u548c\u5e76\u53d1\u652f\u6301"""<\/p>\n
def __init__(self, app, cache_size=1000, ttl=300):
\n self.app = app
\n self.cache_size = cache_size
\n self.ttl = ttl # \u7f13\u5b58\u751f\u5b58\u65f6\u95f4（\u79d2）<\/p>\n
# \u7ebf\u7a0b\u5b89\u5168\u7684\u7f13\u5b58
\n self.cache = {}
\n self.cache_timestamps = {}
\n self.cache_lock = threading.Lock()<\/p>\n
# \u8def\u7531\u524d\u7f00\u6811，\u7528\u4e8e\u5feb\u901f\u5339\u914d
\n self.route_trie = self.build_route_trie()<\/p>\n
# \u70ed\u70b9\u8def\u7531\u7edf\u8ba1
\n self.route_stats = defaultdict(int)
\n self.hot_routes = set()<\/p>\n
def build_route_trie(self):
\n """\u6784\u5efa\u8def\u7531\u524d\u7f00\u6811"""
\n trie = {}<\/p>\n
for rule in self.app.url_map.iter_rules():
\n path = rule.rule
\n methods = frozenset(rule.methods)<\/p>\n
# \u6784\u5efatrie
\n current = trie
\n for segment in path.split('\/'):
\n if segment.startswith('<'):
\n # \u53c2\u6570\u6bb5，\u4f7f\u7528\u901a\u914d\u7b26
\n if '*' not in current:
\n current['*'] = {}
\n current = current['*']
\n else:
\n if segment not in current:
\n current[segment] = {}
\n current = current[segment]<\/p>\n
# \u5b58\u50a8\u7aef\u70b9\u7684\u65b9\u6cd5
\n current['__methods__'] = methods
\n current['__endpoint__'] = rule.endpoint<\/p>\n
return trie<\/p>\n
def find_route_methods(self, path: str) -> Tuple[str, Set[str]]:
\n """\u4f7f\u7528trie\u67e5\u627e\u8def\u7531\u548c\u65b9\u6cd5"""
\n segments = path.strip('\/').split('\/')<\/p>\n
current = self.route_trie
\n params = {}<\/p>\n
for segment in segments:
\n if segment in current:
\n current = current[segment]
\n elif '*' in current:
\n current = current['*']
\n params[segment] = segment
\n else:
\n return None, set()<\/p>\n
if '__methods__' in current:
\n return current.get('__endpoint__'), current['__methods__']<\/p>\n
return None, set()<\/p>\n
@lru_cache(maxsize=1000)
\n def get_allowed_methods_cached(self, endpoint: str) -> Set[str]:
\n """\u5e26\u7f13\u5b58\u7684\u65b9\u6cd5\u83b7\u53d6"""
\n # \u5b9e\u9645\u67e5\u8be2\u903b\u8f91
\n for rule in self.app.url_map.iter_rules():
\n if rule.endpoint == endpoint:
\n return frozenset(rule.methods)
\n return frozenset()<\/p>\n
def validate_method_optimized(self, path: str, method: str) -> dict:
\n """\u4f18\u5316\u7684\u65b9\u6cd5\u9a8c\u8bc1"""
\n start_time = time.time()<\/p>\n
# \u68c0\u67e5\u7f13\u5b58
\n cache_key = (path, method)<\/p>\n
with self.cache_lock:
\n if cache_key in self.cache:
\n cache_entry = self.cache[cache_key]
\n if time.time() – self.cache_timestamps[cache_key] < self.ttl:
\n # \u7f13\u5b58\u547d\u4e2d
\n self.cache_timestamps[cache_key] = time.time()
\n return cache_entry<\/p>\n
# \u7f13\u5b58\u672a\u547d\u4e2d，\u4f7f\u7528trie\u67e5\u627e
\n endpoint, allowed_methods = self.find_route_methods(path)<\/p>\n
if not endpoint:
\n # \u6ca1\u6709\u627e\u5230\u8def\u7531
\n result = {
\n 'valid': False,
\n 'allowed_methods': {'OPTIONS'},
\n 'reason': 'ROUTE_NOT_FOUND',
\n 'endpoint': None
\n }
\n else:
\n # \u627e\u5230\u8def\u7531，\u68c0\u67e5\u65b9\u6cd5
\n is_valid = method in allowed_methods<\/p>\n
# \u66f4\u65b0\u8def\u7531\u7edf\u8ba1
\n self.route_stats[endpoint] += 1
\n if self.route_stats[endpoint] > 100:
\n self.hot_routes.add(endpoint)<\/p>\n
result = {
\n 'valid': is_valid,
\n 'allowed_methods': allowed_methods,
\n 'reason': 'METHOD_NOT_ALLOWED' if not is_valid else 'OK',
\n 'endpoint': endpoint
\n }<\/p>\n
# \u7f13\u5b58\u7ed3\u679c（\u5982\u679c\u503c\u5f97\u7f13\u5b58）
\n if self.should_cache_result(result, path):
\n with self.cache_lock:
\n # \u6e05\u7406\u8fc7\u671f\u7f13\u5b58
\n self.cleanup_cache()<\/p>\n
# \u5b58\u50a8\u65b0\u7f13\u5b58
\n self.cache[cache_key] = result
\n self.cache_timestamps[cache_key] = time.time()<\/p>\n
# \u8bb0\u5f55\u6027\u80fd\u6570\u636e
\n elapsed = time.time() – start_time
\n if elapsed > 0.01: # \u8d85\u8fc710ms
\n self.log_slow_validation(path, method, elapsed)<\/p>\n
return result<\/p>\n
def should_cache_result(self, result: dict, path: str) -> bool:
\n """\u5224\u65ad\u662f\u5426\u5e94\u8be5\u7f13\u5b58\u7ed3\u679c"""
\n # \u4e0d\u7f13\u5b58\u7684\u60c5\u51b5：
\n # 1. \u8def\u7531\u672a\u627e\u5230
\n if not result['endpoint']:
\n return False<\/p>\n
# 2. \u8def\u5f84\u5305\u542b\u53c2\u6570（\u52a8\u6001\u8def\u5f84）
\n if re.search(r'\/\\\\d+|\/[a-f0-9]{32}|\/[^\/]+\/[^\/]+\/[^\/]+', path):
\n return False<\/p>\n
# 3. \u70ed\u70b9\u8def\u7531\u603b\u662f\u7f13\u5b58
\n if result['endpoint'] in self.hot_routes:
\n return True<\/p>\n
# 4. \u9759\u6001\u8def\u5f84\u6216\u7b80\u5355API\u8def\u5f84
\n if re.match(r'^\/api\/([^\/]+)$', path) or re.match(r'^\/static\/', path):
\n return True<\/p>\n
return False<\/p>\n
def cleanup_cache(self):
\n """\u6e05\u7406\u8fc7\u671f\u7f13\u5b58"""
\n if len(self.cache) < self.cache_size * 1.5:
\n return # \u7f13\u5b58\u672a\u6ee1，\u4e0d\u9700\u8981\u6e05\u7406<\/p>\n
current_time = time.time()
\n expired_keys = []<\/p>\n
for key, timestamp in self.cache_timestamps.items():
\n if current_time – timestamp > self.ttl:
\n expired_keys.append(key)<\/p>\n
# \u79fb\u9664\u8fc7\u671f\u7f13\u5b58
\n for key in expired_keys:
\n self.cache.pop(key, None)
\n self.cache_timestamps.pop(key, None)<\/p>\n
# \u5982\u679c\u4ecd\u7136\u592a\u5927，\u79fb\u9664\u6700\u65e7\u7684
\n if len(self.cache) > self.cache_size:
\n sorted_keys = sorted(
\n self.cache_timestamps.items(),
\n key=lambda x: x[1]
\n )[:len(self.cache) – self.cache_size]<\/p>\n
for key, _ in sorted_keys:
\n self.cache.pop(key, None)
\n self.cache_timestamps.pop(key, None)<\/p>\n
def log_slow_validation(self, path: str, method: str, elapsed: float):
\n """\u8bb0\u5f55\u6162\u901f\u9a8c\u8bc1"""
\n log_entry = {
\n 'timestamp': datetime.utcnow().isoformat(),
\n 'path': path,
\n 'method': method,
\n 'elapsed_ms': round(elapsed * 1000, 2),
\n 'type': 'slow_method_validation'
\n }<\/p>\n
with open('performance_logs.jsonl', 'a') as f:
\n f.write(json.dumps(log_entry) + '\\\\n')<\/p>\n
# \u5982\u679c\u7279\u522b\u6162，\u53d1\u9001\u8b66\u62a5
\n if elapsed > 0.1: # \u8d85\u8fc7100ms
\n self.send_performance_alert(log_entry)<\/p>\n
def get_performance_report(self) -> dict:
\n """\u83b7\u53d6\u6027\u80fd\u62a5\u544a"""
\n with self.cache_lock:
\n cache_stats = {
\n 'total_cached': len(self.cache),
\n 'cache_hits': getattr(self, 'cache_hits', 0),
\n 'cache_misses': getattr(self, 'cache_misses', 0),
\n 'hot_routes': len(self.hot_routes)
\n }<\/p>\n
# \u8ba1\u7b97\u547d\u4e2d\u7387
\n total = cache_stats['cache_hits'] + cache_stats['cache_misses']
\n cache_stats['hit_rate'] = cache_stats['cache_hits'] \/ total if total > 0 else 0<\/p>\n
return {
\n 'cache': cache_stats,
\n 'route_stats': dict(sorted(
\n self.route_stats.items(),
\n key=lambda x: x[1],
\n reverse=True
\n )[:10])
\n }<\/p>\n
def send_performance_alert(self, log_entry: dict):
\n """\u53d1\u9001\u6027\u80fd\u8b66\u62a5"""
\n alert = {
\n 'type': 'slow_method_validation',
\n 'data': log_entry,
\n 'timestamp': datetime.utcnow().isoformat(),
\n 'severity': 'warning'
\n }<\/p>\n
print(f"[Performance Alert] {json.dumps(alert)}")<\/p>\n
# \u96c6\u6210\u4f18\u5316\u7684\u9a8c\u8bc1\u5668
\noptimized_validator = OptimizedMethodValidator(app)<\/p>\n
@app.before_request
\ndef fast_method_validation():
\n """\u5feb\u901f\u65b9\u6cd5\u9a8c\u8bc1\u4e2d\u95f4\u4ef6"""
\n # \u8df3\u8fc7OPTIONS\u548cHEAD\u65b9\u6cd5
\n if request.method in ['OPTIONS', 'HEAD']:
\n return<\/p>\n
# \u4f7f\u7528\u4f18\u5316\u9a8c\u8bc1\u5668
\n validation_result = optimized_validator.validate_method_optimized(
\n request.path,
\n request.method
\n )<\/p>\n
if not validation_result['valid']:
\n # \u7acb\u5373\u8fd4\u56de405，\u907f\u514d\u8fdb\u5165\u89c6\u56fe\u51fd\u6570
\n response = jsonify({
\n 'error': {
\n 'code': 'METHOD_NOT_ALLOWED',
\n 'message': f'Method {request.method} is not allowed for this endpoint',
\n 'allowed_methods': list(validation_result['allowed_methods'])
\n }
\n })<\/p>\n
response.status_code = 405
\n response.headers['Allow'] = ', '.join(validation_result['allowed_methods'])<\/p>\n
return response<\/p>\n
# \u6027\u80fd\u76d1\u63a7\u7aef\u70b9
\n@app.route('\/api\/performance\/method-validation')
\ndef get_method_validation_stats():
\n """\u83b7\u53d6\u65b9\u6cd5\u9a8c\u8bc1\u6027\u80fd\u7edf\u8ba1"""
\n report = optimized_validator.get_performance_report()
\n return jsonify(report)<\/p>\n
python<\/p>\n
# API\u7248\u672c\u8fc1\u79fb\u4e2d\u7684\u65b9\u6cd5\u5904\u7406
\nclass APIVersionMigrationHandler:
\n """\u5904\u7406API\u7248\u672c\u8fc1\u79fb\u4e2d\u7684\u65b9\u6cd5\u53d8\u5316"""<\/p>\n
def __init__(self):
\n self.version_mappings = {
\n 'v1': {
\n 'deprecated_methods': {
\n 'PUT': {
\n 'since': '2024-01-01',
\n 'alternative': 'PATCH',
\n 'sunset': '2025-01-01'
\n },
\n 'POST': {
\n 'since': '2024-03-01',
\n 'alternative': 'PUT',
\n 'contexts': ['\/api\/v1\/users\/<id>\/permissions']
\n }
\n },
\n 'new_methods': {
\n 'PATCH': {
\n 'introduced': '2024-01-01',
\n 'description': 'Partial updates'
\n }
\n }
\n },
\n 'v2': {
\n 'deprecated_methods': {},
\n 'new_methods': {
\n 'PATCH': {},
\n 'HEAD': {
\n 'introduced': '2024-01-01',
\n 'description': 'Resource metadata'
\n }
\n }
\n }
\n }<\/p>\n
self.version_redirects = {
\n '\/api\/v1\/users': '\/api\/v2\/users',
\n '\/api\/v1\/products': '\/api\/v2\/products'
\n }<\/p>\n
def handle_method_for_version(self, path: str, method: str, request) -> dict:
\n """\u5904\u7406\u7279\u5b9a\u7248\u672c\u7684\u65b9\u6cd5"""
\n # \u63d0\u53d6API\u7248\u672c
\n version = self.extract_api_version(path)<\/p>\n
if not version:
\n return {'proceed': True}<\/p>\n
# \u68c0\u67e5\u662f\u5426\u6709\u91cd\u5b9a\u5411
\n redirected_path = self.check_version_redirect(path)
\n if redirected_path:
\n return {
\n 'proceed': False,
\n 'action': 'redirect',
\n 'new_path': redirected_path,
\n 'status': 301
\n }<\/p>\n
# \u68c0\u67e5\u65b9\u6cd5\u5f03\u7528
\n deprecation_info = self.check_method_deprecation(version, path, method)
\n if deprecation_info:
\n return {
\n 'proceed': True,
\n 'deprecation': deprecation_info
\n }<\/p>\n
# \u68c0\u67e5\u65b9\u6cd5\u652f\u6301
\n if not self.is_method_supported(version, path, method):
\n # \u63d0\u4f9b\u7248\u672c\u7279\u5b9a\u7684405\u54cd\u5e94
\n return {
\n 'proceed': False,
\n 'action': 'version_specific_405',
\n 'version': version,
\n 'method': method
\n }<\/p>\n
return {'proceed': True}<\/p>\n
def extract_api_version(self, path: str) -> str:
\n """\u63d0\u53d6API\u7248\u672c"""
\n match = re.match(r'^\/api\/(v[0-9]+)\/', path)
\n return match.group(1) if match else None<\/p>\n
def check_version_redirect(self, path: str) -> str:
\n """\u68c0\u67e5\u7248\u672c\u91cd\u5b9a\u5411"""
\n for old_path, new_path in self.version_redirects.items():
\n if path.startswith(old_path):
\n # \u66ff\u6362\u8def\u5f84\u524d\u7f00
\n return path.replace(old_path, new_path, 1)
\n return None<\/p>\n
def check_method_deprecation(self, version: str, path: str, method: str) -> dict:
\n """\u68c0\u67e5\u65b9\u6cd5\u662f\u5426\u5df2\u5f03\u7528"""
\n if version not in self.version_mappings:
\n return None<\/p>\n
deprecated_methods = self.version_mappings[version].get('deprecated_methods', {})<\/p>\n
if method in deprecated_methods:
\n info = deprecated_methods[method]<\/p>\n
# \u68c0\u67e5\u662f\u5426\u9002\u7528\u4e8e\u5f53\u524d\u4e0a\u4e0b\u6587
\n if 'contexts' in info:
\n if not any(path.startswith(ctx.replace('<id>', '')) for ctx in info['contexts']):
\n return None<\/p>\n
return {
\n 'method': method,
\n 'deprecated_since': info['since'],
\n 'alternative': info.get('alternative'),
\n 'sunset': info.get('sunset'),
\n 'message': f'Method {method} is deprecated in {version}'
\n }<\/p>\n
return None<\/p>\n
def is_method_supported(self, version: str, path: str, method: str) -> bool:
\n """\u68c0\u67e5\u65b9\u6cd5\u5728\u7279\u5b9a\u7248\u672c\u4e2d\u662f\u5426\u652f\u6301"""
\n # \u83b7\u53d6\u57fa\u7840\u5141\u8bb8\u7684\u65b9\u6cd5
\n endpoint = request.endpoint
\n if endpoint:
\n allowed_methods = method_manager.get_allowed_methods(endpoint)
\n return method in allowed_methods<\/p>\n
# \u7248\u672c\u7279\u5b9a\u7684\u68c0\u67e5
\n if version == 'v1':
\n # v1\u4e0d\u652f\u6301PATCH
\n if method == 'PATCH':
\n return False<\/p>\n
return True<\/p>\n
def create_version_specific_405(self, version: str, method: str, path: str) -> tuple:
\n """\u521b\u5efa\u7248\u672c\u7279\u5b9a\u7684405\u54cd\u5e94"""
\n # \u83b7\u53d6\u5141\u8bb8\u7684\u65b9\u6cd5
\n endpoint = request.endpoint
\n allowed_methods = method_manager.get_allowed_methods(endpoint) if endpoint else set()<\/p>\n
# \u7248\u672c\u7279\u5b9a\u7684\u8c03\u6574
\n if version == 'v1':
\n # v1\u4e2d\u79fb\u9664PATCH
\n allowed_methods = {m for m in allowed_methods if m != 'PATCH'}<\/p>\n
response_data = {
\n "error": {
\n "code": "METHOD_NOT_ALLOWED",
\n "message": f"Method {method} is not supported in API {version}",
\n "api_version": version,
\n "allowed_methods": list(allowed_methods),
\n "version_specific": True
\n }
\n }<\/p>\n
# \u6dfb\u52a0\u7248\u672c\u8fc1\u79fb\u4fe1\u606f
\n if version == 'v1':
\n response_data["error"]["migration_note"] = (
\n "Consider migrating to API v2 for additional features and methods."
\n )
\n response_data["error"]["v2_endpoint"] = f"\/api\/v2{path[7:]}" # \u79fb\u9664\/v1\u524d\u7f00<\/p>\n
response = jsonify(response_data)
\n response.status_code = 405
\n response.headers['Allow'] = ', '.join(allowed_methods)
\n response.headers['X-API-Version'] = version
\n response.headers['Deprecation'] = 'true'<\/p>\n
return response<\/p>\n
def create_deprecation_response(self, deprecation_info: dict) -> tuple:
\n """\u521b\u5efa\u5f03\u7528\u8b66\u544a\u54cd\u5e94"""
\n response = jsonify({
\n "warning": {
\n "code": "METHOD_DEPRECATED",
\n "message": deprecation_info['message'],
\n "deprecated_method": deprecation_info['method'],
\n "deprecated_since": deprecation_info['deprecated_since'],
\n "alternative_method": deprecation_info.get('alternative'),
\n "sunset_date": deprecation_info.get('sunset'),
\n "documentation": f"https:\/\/api.example.com\/docs\/migration-guide"
\n }
\n })<\/p>\n
response.status_code = 200 # \u4ecd\u7136\u5904\u7406\u8bf7\u6c42，\u4f46\u6dfb\u52a0\u8b66\u544a
\n response.headers['Deprecation'] = f'date="{deprecation_info["deprecated_since"]}"'<\/p>\n
if deprecation_info.get('sunset'):
\n response.headers['Sunset'] = deprecation_info['sunset']<\/p>\n
if deprecation_info.get('alternative'):
\n response.headers['Link'] = (
\n f'<\/api\/v2{request.path[7:]}>; rel="successor-version"; type="application\/json"'
\n )<\/p>\n
return response<\/p>\n
# \u96c6\u6210\u7248\u672c\u8fc1\u79fb\u5904\u7406\u5668
\nversion_handler = APIVersionMigrationHandler()<\/p>\n
@app.before_request
\ndef handle_api_version_migration():
\n """\u5904\u7406API\u7248\u672c\u8fc1\u79fb"""
\n # \u68c0\u67e5API\u7248\u672c\u548c\u65b9\u6cd5
\n result = version_handler.handle_method_for_version(
\n request.path, request.method, request
\n )<\/p>\n
if not result['proceed']:
\n if result['action'] == 'redirect':
\n # \u91cd\u5b9a\u5411\u5230\u65b0\u7248\u672c
\n response = jsonify({
\n "error": {
\n "code": "VERSION_REDIRECT",
\n "message": f"API endpoint has moved to {result['new_path']}",
\n "new_location": result['new_path']
\n }
\n })
\n response.status_code = result['status']
\n response.headers['Location'] = result['new_path']
\n return response<\/p>\n
elif result['action'] == 'version_specific_405':
\n # \u7248\u672c\u7279\u5b9a\u7684405
\n return version_handler.create_version_specific_405(
\n result['version'], result['method'], request.path
\n )<\/p>\n
elif 'deprecation' in result:
\n # \u65b9\u6cd5\u5df2\u5f03\u7528，\u6dfb\u52a0\u8b66\u544a\u5934\u90e8
\n request.deprecation_info = result['deprecation']<\/p>\n
@app.after_request
\ndef add_deprecation_headers(response):
\n """\u6dfb\u52a0\u5f03\u7528\u5934\u90e8"""
\n if hasattr(request, 'deprecation_info'):
\n deprecation_info = request.deprecation_info<\/p>\n
response.headers['Deprecation'] = f'date="{deprecation_info["deprecated_since"]}"'<\/p>\n
if deprecation_info.get('sunset'):
\n response.headers['Sunset'] = deprecation_info['sunset']<\/p>\n
# \u5982\u679c\u54cd\u5e94\u662fJSON，\u53ef\u4ee5\u5728\u54cd\u5e94\u4f53\u4e2d\u6dfb\u52a0\u8b66\u544a
\n if response.headers.get('Content-Type', '').startswith('application\/json'):
\n try:
\n data = json.loads(response.get_data(as_text=True))
\n if isinstance(data, dict):
\n data['_warning'] = {
\n 'deprecated_method': deprecation_info['method'],
\n 'message': deprecation_info['message'],
\n 'alternative': deprecation_info.get('alternative')
\n }
\n response.set_data(json.dumps(data))
\n except:
\n pass # \u5ffd\u7565JSON\u89e3\u6790\u9519\u8bef<\/p>\n
return response<\/p>\n
408 Request Timeout\u00a0\u72b6\u6001\u7801\u8868\u793a\u670d\u52a1\u5668\u5728\u7b49\u5f85\u8bf7\u6c42\u7684\u5b8c\u6574\u4f20\u8f93\u65f6\u8d85\u8fc7\u4e86\u9884\u8bbe\u7684\u65f6\u95f4\u9650\u5236\u3002\u8be5\u72b6\u6001\u7801\u7684\u6838\u5fc3\u542b\u4e49\u662f：<\/p>\n
\u670d\u52a1\u5668\u6ca1\u6709\u5728\u671f\u671b\u7684\u65f6\u95f4\u5185\u6536\u5230\u5b8c\u6574\u7684\u8bf7\u6c42<\/p>\n<\/li>\n
\u8fde\u63a5\u53ef\u80fd\u4ecd\u7136\u4fdd\u6301\u6253\u5f00\u72b6\u6001<\/p>\n<\/li>\n
\u5ba2\u6237\u7aef\u53ef\u4ee5\u5728\u7a0d\u540e\u65f6\u95f4\u7528\u76f8\u540c\u7684\u8bf7\u6c42\u91cd\u8bd5<\/p>\n<\/li>\n<\/ul>\n
\u5173\u952e\u7279\u6027：<\/p>\n
\u4e0d\u662f\u5ba2\u6237\u7aef\u9519\u8bef：\u800c\u662f\u5ba2\u6237\u7aef\u4e0e\u670d\u52a1\u5668\u4e4b\u95f4\u7684\u901a\u4fe1\u95ee\u9898<\/p>\n<\/li>\n
\u670d\u52a1\u5668\u4e3b\u52a8\u5173\u95ed\u8fde\u63a5：\u7531\u4e8e\u8d85\u65f6\u800c\u7ec8\u6b62\u7b49\u5f85<\/p>\n<\/li>\n
\u4e0e504 Gateway Timeout\u7684\u533a\u522b：504\u662f\u4e0a\u6e38\u670d\u52a1\u5668\u8d85\u65f6，408\u662f\u5ba2\u6237\u7aef\u8bf7\u6c42\u8d85\u65f6<\/p>\n<\/li>\n<\/ul>\n
\u534f\u8bae\u8981\u6c42：<\/p>\n
\u670d\u52a1\u5668\u5e94\u8be5\u53d1\u9001\u4e00\u4e2a\u5173\u95ed\u8fde\u63a5\u7684\u54cd\u5e94<\/p>\n<\/li>\n
\u53ef\u4ee5\u5305\u542b\u63cf\u8ff0\u8d85\u65f6\u7684\u54cd\u5e94\u4f53<\/p>\n<\/li>\n
\u5ba2\u6237\u7aef\u53ef\u4ee5\u91cd\u8bd5\u76f8\u540c\u7684\u8bf7\u6c42<\/p>\n<\/li>\n<\/ul>\n
python<\/p>\n
# \u7f51\u7edc\u5c42\u8d85\u65f6\u5206\u6790
\nclass NetworkTimeoutAnalyzer:
\n def __init__(self):
\n self.timeout_scenarios = {
\n # 1. \u8fde\u63a5\u5efa\u7acb\u8d85\u65f6
\n 'tcp_handshake': {
\n 'description': 'TCP\u4e09\u6b21\u63e1\u624b\u672a\u5728\u65f6\u95f4\u5185\u5b8c\u6210',
\n 'typical_timeout': 60, # \u79d2
\n 'common_causes': [
\n '\u7f51\u7edc\u62e5\u585e',
\n '\u9632\u706b\u5899\u963b\u6b62',
\n 'DNS\u89e3\u6790\u5931\u8d25'
\n ]
\n },<\/p>\n
# 2. TLS\u63e1\u624b\u8d85\u65f6
\n 'tls_handshake': {
\n 'description': 'TLS\u63e1\u624b\u8fc7\u7a0b\u8d85\u65f6',
\n 'typical_timeout': 30, # \u79d2
\n 'common_causes': [
\n '\u8bc1\u4e66\u94fe\u9a8c\u8bc1\u590d\u6742',
\n '\u5ba2\u6237\u7aef\/\u670d\u52a1\u5668CPU\u8d1f\u8f7d\u9ad8',
\n '\u5f31\u52a0\u5bc6\u5957\u4ef6\u534f\u5546'
\n ]
\n },<\/p>\n
# 3. \u8bf7\u6c42\u5934\u4f20\u8f93\u8d85\u65f6
\n 'headers_transmission': {
\n 'description': '\u8bf7\u6c42\u5934\u4f20\u8f93\u65f6\u95f4\u8fc7\u957f',
\n 'typical_timeout': 30, # \u79d2
\n 'common_causes': [
\n '\u5934\u90e8\u8fc7\u5927（\u5982Cookie）',
\n '\u7f51\u7edc\u5e26\u5bbd\u9650\u5236',
\n '\u4ee3\u7406\u670d\u52a1\u5668\u5904\u7406\u5ef6\u8fdf'
\n ]
\n },<\/p>\n
# 4. \u8bf7\u6c42\u4f53\u4f20\u8f93\u8d85\u65f6
\n 'body_transmission': {
\n 'description': '\u8bf7\u6c42\u4f53\u4f20\u8f93\u65f6\u95f4\u8fc7\u957f',
\n 'typical_timeout': 60, # \u79d2
\n 'common_causes': [
\n '\u5927\u6587\u4ef6\u4e0a\u4f20',
\n '\u6162\u901f\u7f51\u7edc\u8fde\u63a5',
\n '\u5ba2\u6237\u7aef\u5904\u7406\u5ef6\u8fdf'
\n ]
\n },<\/p>\n
# 5. \u6162\u901floris\u653b\u51fb
\n 'slow_loris': {
\n 'description': '\u5ba2\u6237\u7aef\u7f13\u6162\u53d1\u9001\u6570\u636e，\u5360\u7528\u8fde\u63a5',
\n 'typical_timeout': 300, # \u79d2
\n 'common_causes': [
\n '\u6076\u610f\u653b\u51fb',
\n '\u5ba2\u6237\u7aef\u5b9e\u73b0\u7f3a\u9677',
\n '\u7f51\u7edc\u95ee\u9898'
\n ]
\n }
\n }<\/p>\n
def analyze_timeout(self, request_data, network_stats):
\n """\u5206\u6790\u8d85\u65f6\u539f\u56e0"""
\n timeout_type = self.determine_timeout_type(request_data, network_stats)<\/p>\n
if timeout_type:
\n scenario = self.timeout_scenarios[timeout_type]
\n return {
\n 'type': timeout_type,
\n 'description': scenario['description'],
\n 'causes': self.rank_causes(request_data, scenario['common_causes']),
\n 'recommendations': self.generate_recommendations(timeout_type)
\n }<\/p>\n
return None<\/p>\n
def determine_timeout_type(self, request_data, network_stats):
\n """\u786e\u5b9a\u8d85\u65f6\u7c7b\u578b"""<\/p>\n
# \u5206\u6790\u8fde\u63a5\u65f6\u95f4
\n if network_stats.get('connection_time', 0) > 60:
\n return 'tcp_handshake'<\/p>\n
# \u5206\u6790TLS\u63e1\u624b\u65f6\u95f4
\n if network_stats.get('tls_handshake_time', 0) > 30:
\n return 'tls_handshake'<\/p>\n
# \u5206\u6790\u8bf7\u6c42\u5934\u5927\u5c0f
\n headers_size = sum(len(k) + len(v) for k, v in request_data.get('headers', {}).items())
\n if headers_size > 8192: # 8KB
\n return 'headers_transmission'<\/p>\n
# \u5206\u6790\u8bf7\u6c42\u4f53\u5927\u5c0f\u548c\u4f20\u8f93\u901f\u7387
\n body_size = request_data.get('content_length', 0)
\n if body_size > 10 * 1024 * 1024: # 10MB
\n if network_stats.get('transfer_rate', 0) < 1024: # < 1KB\/s
\n return 'body_transmission'<\/p>\n
# \u68c0\u67e5\u6162\u901floris\u6a21\u5f0f
\n if self.is_slow_loris_pattern(request_data, network_stats):
\n return 'slow_loris'<\/p>\n
return None<\/p>\n
def is_slow_loris_pattern(self, request_data, network_stats):
\n """\u68c0\u6d4b\u6162\u901floris\u653b\u51fb\u6a21\u5f0f"""
\n # \u68c0\u67e5\u8bf7\u6c42\u662f\u5426\u5206\u6bb5\u4f20\u8f93
\n if network_stats.get('chunk_count', 0) > 10:
\n # \u68c0\u67e5\u4f20\u8f93\u95f4\u9694
\n intervals = network_stats.get('chunk_intervals', [])
\n if intervals:
\n avg_interval = sum(intervals) \/ len(intervals)
\n if 1 < avg_interval < 10: # \u6bcf\u79d2\u53d1\u9001\u5c11\u91cf\u6570\u636e
\n return True<\/p>\n
# \u68c0\u67e5Keep-Alive\u6ee5\u7528
\n if network_stats.get('keep_alive_requests', 0) > 100:
\n return True<\/p>\n
return False<\/p>\n
def rank_causes(self, request_data, possible_causes):
\n """\u5bf9\u53ef\u80fd\u539f\u56e0\u8fdb\u884c\u6392\u5e8f"""
\n ranked = []<\/p>\n
# \u57fa\u4e8e\u8bf7\u6c42\u7279\u5f81\u6392\u5e8f
\n for cause in possible_causes:
\n score = 0<\/p>\n
if cause == '\u7f51\u7edc\u62e5\u585e' and request_data.get('high_latency', False):
\n score += 3<\/p>\n
if cause == '\u5927\u6587\u4ef6\u4e0a\u4f20' and request_data.get('content_length', 0) > 5 * 1024 * 1024:
\n score += 3<\/p>\n
if cause == '\u6076\u610f\u653b\u51fb' and self.is_slow_loris_pattern(request_data, {}):
\n score += 5<\/p>\n
ranked.append((cause, score))<\/p>\n
# \u6309\u5206\u6570\u6392\u5e8f
\n ranked.sort(key=lambda x: x[1], reverse=True)
\n return [cause for cause, score in ranked if score > 0]<\/p>\n
def generate_recommendations(self, timeout_type):
\n """\u751f\u6210\u63a8\u8350\u89e3\u51b3\u65b9\u6848"""
\n recommendations = {
\n 'tcp_handshake': [
\n '\u68c0\u67e5\u7f51\u7edc\u8fde\u63a5\u7a33\u5b9a\u6027',
\n '\u9a8c\u8bc1\u9632\u706b\u5899\u914d\u7f6e',
\n '\u4f7f\u7528\u8fde\u63a5\u6c60\u51cf\u5c11\u63e1\u624b\u6b21\u6570'
\n ],
\n 'tls_handshake': [
\n '\u4f18\u5316\u8bc1\u4e66\u94fe',
\n '\u4f7f\u7528\u66f4\u5feb\u7684\u52a0\u5bc6\u7b97\u6cd5',
\n '\u542f\u7528TLS\u4f1a\u8bdd\u6062\u590d'
\n ],
\n 'headers_transmission': [
\n '\u51cf\u5c11Cookie\u5927\u5c0f',
\n '\u538b\u7f29\u8bf7\u6c42\u5934',
\n '\u4f7f\u7528HTTP\/2\u5934\u90e8\u538b\u7f29'
\n ],
\n 'body_transmission': [
\n '\u5206\u5757\u4e0a\u4f20\u5927\u6587\u4ef6',
\n '\u542f\u7528\u538b\u7f29',
\n '\u589e\u52a0\u8d85\u65f6\u65f6\u95f4'
\n ],
\n 'slow_loris': [
\n '\u914d\u7f6e\u8bf7\u6c42\u901f\u7387\u9650\u5236',
\n '\u9650\u5236\u6700\u5c0f\u4f20\u8f93\u901f\u7387',
\n '\u4f7f\u7528Web\u5e94\u7528\u9632\u706b\u5899'
\n ]
\n }<\/p>\n
return recommendations.get(timeout_type, [])<\/p>\n
python<\/p>\n
# \u5e94\u7528\u5c42\u8d85\u65f6\u573a\u666f\u5206\u6790
\nclass ApplicationTimeoutAnalyzer:
\n def __init__(self):
\n self.request_stages = {
\n 'parsing': {
\n 'description': '\u8bf7\u6c42\u89e3\u6790\u9636\u6bb5',
\n 'timeout': 5, # \u79d2
\n 'metrics': ['request_size', 'complexity']
\n },
\n 'authentication': {
\n 'description': '\u8eab\u4efd\u9a8c\u8bc1\u9636\u6bb5',
\n 'timeout': 10,
\n 'metrics': ['auth_method', 'token_validation']
\n },
\n 'authorization': {
\n 'description': '\u6388\u6743\u68c0\u67e5\u9636\u6bb5',
\n 'timeout': 5,
\n 'metrics': ['permission_checks', 'role_validation']
\n },
\n 'validation': {
\n 'description': '\u8bf7\u6c42\u9a8c\u8bc1\u9636\u6bb5',
\n 'timeout': 10,
\n 'metrics': ['data_size', 'validation_rules']
\n },
\n 'processing': {
\n 'description': '\u4e1a\u52a1\u5904\u7406\u9636\u6bb5',
\n 'timeout': 30,
\n 'metrics': ['complexity', 'external_calls']
\n },
\n 'response': {
\n 'description': '\u54cd\u5e94\u751f\u6210\u9636\u6bb5',
\n 'timeout': 10,
\n 'metrics': ['response_size', 'serialization']
\n }
\n }<\/p>\n
def track_request_stage(self, request_id, stage, start_time):
\n """\u8ddf\u8e2a\u8bf7\u6c42\u9636\u6bb5"""
\n return {
\n 'request_id': request_id,
\n 'stage': stage,
\n 'start_time': start_time,
\n 'timeout': self.request_stages[stage]['timeout']
\n }<\/p>\n
def check_stage_timeout(self, stage_info):
\n """\u68c0\u67e5\u9636\u6bb5\u662f\u5426\u8d85\u65f6"""
\n current_time = time.time()
\n elapsed = current_time – stage_info['start_time']<\/p>\n
if elapsed > stage_info['timeout']:
\n return {
\n 'timed_out': True,
\n 'stage': stage_info['stage'],
\n 'elapsed': elapsed,
\n 'timeout': stage_info['timeout'],
\n 'description': self.request_stages[stage_info['stage']]['description']
\n }<\/p>\n
return {'timed_out': False}<\/p>\n
def analyze_staleness(self, request_data):
\n """\u5206\u6790\u8bf7\u6c42\u9648\u65e7\u6027"""
\n # \u68c0\u67e5\u8bf7\u6c42\u662f\u5426\u5728\u961f\u5217\u4e2d\u7b49\u5f85\u592a\u4e45
\n received_time = request_data.get('received_time')
\n start_time = request_data.get('start_time')<\/p>\n
if received_time and start_time:
\n queue_time = start_time – received_time<\/p>\n
if queue_time > 30: # \u5728\u961f\u5217\u4e2d\u7b49\u5f85\u8d85\u8fc730\u79d2
\n return {
\n 'stale': True,
\n 'queue_time': queue_time,
\n 'recommendation': '\u589e\u52a0\u5904\u7406\u80fd\u529b\u6216\u51cf\u5c11\u961f\u5217\u957f\u5ea6'
\n }<\/p>\n
return {'stale': False}<\/p>\n
def generate_timeout_response(self, timeout_info):
\n """\u751f\u6210\u8d85\u65f6\u54cd\u5e94"""
\n response = {
\n 'error': {
\n 'code': 'REQUEST_TIMEOUT',
\n 'message': 'Request processing timed out',
\n 'details': {
\n 'stage': timeout_info['stage'],
\n 'elapsed_seconds': round(timeout_info['elapsed'], 2),
\n 'timeout_seconds': timeout_info['timeout'],
\n 'description': timeout_info['description']
\n }
\n }
\n }<\/p>\n
# \u6dfb\u52a0\u6062\u590d\u5efa\u8bae
\n if timeout_info['stage'] == 'processing':
\n response['error']['suggestions'] = [
\n '\u7b80\u5316\u8bf7\u6c42\u590d\u6742\u6027',
\n '\u4f7f\u7528\u5f02\u6b65\u5904\u7406',
\n '\u589e\u52a0\u8d85\u65f6\u65f6\u95f4\u914d\u7f6e'
\n ]<\/p>\n
return response<\/p>\n
python<\/p>\n
# \u5b8c\u6574\u7684\u8d85\u65f6\u7ba1\u7406\u4e2d\u95f4\u4ef6\u5b9e\u73b0
\nimport time
\nimport asyncio
\nfrom concurrent.futures import ThreadPoolExecutor, TimeoutError
\nfrom contextlib import contextmanager
\nfrom typing import Dict, Optional, Callable, Any
\nimport signal
\nimport threading<\/p>\n
class TimeoutManager:
\n """\u5168\u9762\u7684\u8d85\u65f6\u7ba1\u7406\u5668"""<\/p>\n
def __init__(self, config: Dict = None):
\n self.config = {
\n 'connection_timeout': 60, # \u8fde\u63a5\u5efa\u7acb\u8d85\u65f6
\n 'read_timeout': 60, # \u8bfb\u53d6\u8bf7\u6c42\u8d85\u65f6
\n 'write_timeout': 60, # \u5199\u5165\u54cd\u5e94\u8d85\u65f6
\n 'request_timeout': 120, # \u603b\u8bf7\u6c42\u5904\u7406\u8d85\u65f6
\n 'keep_alive_timeout': 15, # Keep-Alive\u8d85\u65f6
\n 'max_header_size': 8192, # \u6700\u5927\u5934\u90e8\u5927\u5c0f
\n 'max_body_size': 10 * 1024 * 1024, # \u6700\u5927\u8bf7\u6c42\u4f53\u5927\u5c0f
\n 'slow_request_threshold': 10, # \u6162\u8bf7\u6c42\u9608\u503c（\u79d2）
\n ** (config or {})
\n }<\/p>\n
self.active_connections = {}
\n self.slow_requests = []
\n self.timeout_stats = {
\n 'total_timeouts': 0,
\n 'by_stage': {},
\n 'by_client': {}
\n }<\/p>\n
# \u521d\u59cb\u5316\u8d85\u65f6\u5904\u7406\u5668
\n self.init_timeout_handlers()<\/p>\n
def init_timeout_handlers(self):
\n """\u521d\u59cb\u5316\u8d85\u65f6\u5904\u7406\u5668"""
\n self.handlers = {
\n 'connection': self.handle_connection_timeout,
\n 'read': self.handle_read_timeout,
\n 'write': self.handle_write_timeout,
\n 'request': self.handle_request_timeout,
\n 'keep_alive': self.handle_keep_alive_timeout
\n }<\/p>\n
@contextmanager
\n def request_context(self, client_ip: str, request_id: str):
\n """\u8bf7\u6c42\u4e0a\u4e0b\u6587\u7ba1\u7406\u5668"""
\n start_time = time.time()
\n connection_info = {
\n 'client_ip': client_ip,
\n 'request_id': request_id,
\n 'start_time': start_time,
\n 'stage': 'initial',
\n 'last_activity': start_time,
\n 'bytes_received': 0,
\n 'bytes_sent': 0
\n }<\/p>\n
self.active_connections[request_id] = connection_info<\/p>\n
try:
\n yield connection_info
\n finally:
\n # \u6e05\u7406\u8fde\u63a5\u4fe1\u606f
\n if request_id in self.active_connections:
\n elapsed = time.time() – start_time<\/p>\n
if elapsed > self.config['slow_request_threshold']:
\n self.record_slow_request(connection_info, elapsed)<\/p>\n
del self.active_connections[request_id]<\/p>\n
def monitor_connection(self, request_id: str):
\n """\u76d1\u63a7\u8fde\u63a5\u72b6\u6001"""
\n def monitor():
\n while request_id in self.active_connections:
\n conn = self.active_connections[request_id]
\n idle_time = time.time() – conn['last_activity']<\/p>\n
# \u68c0\u67e5\u8bfb\u8d85\u65f6
\n if idle_time > self.config['read_timeout'] and conn['stage'] == 'reading':
\n self.handle_timeout('read', conn)
\n break<\/p>\n
# \u68c0\u67e5\u603b\u8bf7\u6c42\u8d85\u65f6
\n total_time = time.time() – conn['start_time']
\n if total_time > self.config['request_timeout']:
\n self.handle_timeout('request', conn)
\n break<\/p>\n
time.sleep(1) # \u6bcf\u79d2\u68c0\u67e5\u4e00\u6b21<\/p>\n
# \u542f\u52a8\u76d1\u63a7\u7ebf\u7a0b
\n thread = threading.Thread(target=monitor, daemon=True)
\n thread.start()
\n return thread<\/p>\n
def handle_timeout(self, timeout_type: str, connection_info: Dict):
\n """\u5904\u7406\u8d85\u65f6"""
\n handler = self.handlers.get(timeout_type)
\n if handler:
\n handler(connection_info)<\/p>\n
# \u8bb0\u5f55\u7edf\u8ba1
\n self.record_timeout(timeout_type, connection_info)<\/p>\n
# \u53d1\u9001\u8b66\u62a5
\n self.send_timeout_alert(timeout_type, connection_info)<\/p>\n
def handle_connection_timeout(self, connection_info: Dict):
\n """\u5904\u7406\u8fde\u63a5\u8d85\u65f6"""
\n # \u8bb0\u5f55\u8fde\u63a5\u8d85\u65f6\u8be6\u60c5
\n log_data = {
\n 'type': 'connection_timeout',
\n 'client_ip': connection_info['client_ip'],
\n 'request_id': connection_info['request_id'],
\n 'stage': connection_info['stage'],
\n 'duration': time.time() – connection_info['start_time'],
\n 'timestamp': time.time()
\n }<\/p>\n
self.log_timeout_event(log_data)<\/p>\n
# \u5173\u95ed\u8fde\u63a5
\n self.close_connection(connection_info)<\/p>\n
def handle_read_timeout(self, connection_info: Dict):
\n """\u5904\u7406\u8bfb\u8d85\u65f6"""
\n log_data = {
\n 'type': 'read_timeout',
\n 'client_ip': connection_info['client_ip'],
\n 'request_id': connection_info['request_id'],
\n 'stage': connection_info['stage'],
\n 'bytes_received': connection_info['bytes_received'],
\n 'idle_time': time.time() – connection_info['last_activity'],
\n 'timestamp': time.time()
\n }<\/p>\n
self.log_timeout_event(log_data)<\/p>\n
# \u68c0\u67e5\u662f\u5426\u662f\u6162\u901floris\u653b\u51fb
\n if self.is_slow_loris_attack(connection_info):
\n self.handle_slow_loris(connection_info)<\/p>\n
def handle_write_timeout(self, connection_info: Dict):
\n """\u5904\u7406\u5199\u8d85\u65f6"""
\n log_data = {
\n 'type': 'write_timeout',
\n 'client_ip': connection_info['client_ip'],
\n 'request_id': connection_info['request_id'],
\n 'stage': connection_info['stage'],
\n 'bytes_sent': connection_info['bytes_sent'],
\n 'timestamp': time.time()
\n }<\/p>\n
self.log_timeout_event(log_data)<\/p>\n
def handle_request_timeout(self, connection_info: Dict):
\n """\u5904\u7406\u8bf7\u6c42\u5904\u7406\u8d85\u65f6"""
\n log_data = {
\n 'type': 'request_timeout',
\n 'client_ip': connection_info['client_ip'],
\n 'request_id': connection_info['request_id'],
\n 'stage': connection_info['stage'],
\n 'total_duration': time.time() – connection_info['start_time'],
\n 'timestamp': time.time()
\n }<\/p>\n
self.log_timeout_event(log_data)<\/p>\n
# \u751f\u6210408\u54cd\u5e94
\n self.send_408_response(connection_info)<\/p>\n
def handle_keep_alive_timeout(self, connection_info: Dict):
\n """\u5904\u7406Keep-Alive\u8d85\u65f6"""
\n log_data = {
\n 'type': 'keep_alive_timeout',
\n 'client_ip': connection_info['client_ip'],
\n 'request_id': connection_info['request_id'],
\n 'idle_time': time.time() – connection_info['last_activity'],
\n 'timestamp': time.time()
\n }<\/p>\n
self.log_timeout_event(log_data)<\/p>\n
def is_slow_loris_attack(self, connection_info: Dict) -> bool:
\n """\u68c0\u6d4b\u6162\u901floris\u653b\u51fb"""
\n # \u68c0\u67e5\u63a5\u6536\u901f\u7387
\n if connection_info['bytes_received'] > 0:
\n duration = time.time() – connection_info['start_time']
\n rate = connection_info['bytes_received'] \/ duration<\/p>\n
if rate < 100: # \u5c0f\u4e8e100\u5b57\u8282\/\u79d2
\n return True<\/p>\n
# \u68c0\u67e5\u957f\u65f6\u95f4\u4fdd\u6301\u8fde\u63a5\u4f46\u6ca1\u6709\u6570\u636e
\n idle_time = time.time() – connection_info['last_activity']
\n if idle_time > 30 and connection_info['bytes_received'] < 100:
\n return True<\/p>\n
return False<\/p>\n
def handle_slow_loris(self, connection_info: Dict):
\n """\u5904\u7406\u6162\u901floris\u653b\u51fb"""
\n # \u6dfb\u52a0\u5230\u9ed1\u540d\u5355
\n self.add_to_blacklist(connection_info['client_ip'])<\/p>\n
# \u7acb\u5373\u5173\u95ed\u8fde\u63a5
\n self.close_connection_immediately(connection_info)<\/p>\n
# \u8bb0\u5f55\u5b89\u5168\u4e8b\u4ef6
\n self.log_security_event('slow_loris_attack', connection_info)<\/p>\n
def send_408_response(self, connection_info: Dict):
\n """\u53d1\u9001408\u54cd\u5e94"""
\n response = self.create_408_response(connection_info)<\/p>\n
# \u5728\u5b9e\u9645\u5e94\u7528\u4e2d，\u8fd9\u91cc\u4f1a\u901a\u8fc7\u8fde\u63a5\u53d1\u9001\u54cd\u5e94
\n # \u4e3a\u4e86\u793a\u4f8b，\u6211\u4eec\u53ea\u8bb0\u5f55
\n self.log_response(response)<\/p>\n
def create_408_response(self, connection_info: Dict) -> Dict:
\n """\u521b\u5efa408\u54cd\u5e94"""
\n response = {
\n 'status_code': 408,
\n 'headers': {
\n 'Content-Type': 'application\/json',
\n 'Connection': 'close',
\n 'X-Request-Timeout': 'true',
\n 'X-Timeout-Stage': connection_info['stage'],
\n 'X-Request-ID': connection_info['request_id']
\n },
\n 'body': {
\n 'error': {
\n 'code': 'REQUEST_TIMEOUT',
\n 'message': 'Server timeout waiting for the request',
\n 'request_id': connection_info['request_id'],
\n 'client_ip': connection_info['client_ip'],
\n 'timeout_type': 'request_processing',
\n 'duration_seconds': round(time.time() – connection_info['start_time'], 2),
\n 'recommendations': [
\n 'Simplify the request',
\n 'Retry with exponential backoff',
\n 'Check network connectivity'
\n ]
\n }
\n }
\n }<\/p>\n
return response<\/p>\n
def record_timeout(self, timeout_type: str, connection_info: Dict):
\n """\u8bb0\u5f55\u8d85\u65f6\u7edf\u8ba1"""
\n self.timeout_stats['total_timeouts'] += 1<\/p>\n
# \u6309\u9636\u6bb5\u7edf\u8ba1
\n stage = connection_info['stage']
\n if stage not in self.timeout_stats['by_stage']:
\n self.timeout_stats['by_stage'][stage] = 0
\n self.timeout_stats['by_stage'][stage] += 1<\/p>\n
# \u6309\u5ba2\u6237\u7aef\u7edf\u8ba1
\n client_ip = connection_info['client_ip']
\n if client_ip not in self.timeout_stats['by_client']:
\n self.timeout_stats['by_client'][client_ip] = 0
\n self.timeout_stats['by_client'][client_ip] += 1<\/p>\n
def record_slow_request(self, connection_info: Dict, duration: float):
\n """\u8bb0\u5f55\u6162\u8bf7\u6c42"""
\n slow_request = {
\n 'request_id': connection_info['request_id'],
\n 'client_ip': connection_info['client_ip'],
\n 'duration': duration,
\n 'stage': connection_info['stage'],
\n 'timestamp': time.time()
\n }<\/p>\n
self.slow_requests.append(slow_request)<\/p>\n
# \u4fdd\u6301\u6700\u8fd11000\u4e2a\u6162\u8bf7\u6c42
\n if len(self.slow_requests) > 1000:
\n self.slow_requests = self.slow_requests[-1000:]<\/p>\n
def log_timeout_event(self, log_data: Dict):
\n """\u8bb0\u5f55\u8d85\u65f6\u4e8b\u4ef6"""
\n # \u5728\u5b9e\u9645\u5e94\u7528\u4e2d，\u8fd9\u91cc\u4f1a\u8bb0\u5f55\u5230\u65e5\u5fd7\u7cfb\u7edf
\n print(f"[Timeout Event] {log_data}")<\/p>\n
# \u5199\u5165\u6587\u4ef6\u65e5\u5fd7
\n with open('timeout_events.log', 'a') as f:
\n f.write(json.dumps(log_data) + '\\\\n')<\/p>\n
def log_response(self, response: Dict):
\n """\u8bb0\u5f55\u54cd\u5e94"""
\n with open('408_responses.log', 'a') as f:
\n f.write(json.dumps(response) + '\\\\n')<\/p>\n
def add_to_blacklist(self, client_ip: str):
\n """\u6dfb\u52a0\u5230\u9ed1\u540d\u5355"""
\n # \u5728\u5b9e\u9645\u5e94\u7528\u4e2d，\u8fd9\u91cc\u4f1a\u66f4\u65b0\u9ed1\u540d\u5355\u5b58\u50a8
\n with open('blacklist.log', 'a') as f:
\n f.write(f"{client_ip},{time.time()}\\\\n")<\/p>\n
def log_security_event(self, event_type: str, data: Dict):
\n """\u8bb0\u5f55\u5b89\u5168\u4e8b\u4ef6"""
\n event = {
\n 'type': event_type,
\n 'data': data,
\n 'timestamp': time.time()
\n }<\/p>\n
with open('security_events.log', 'a') as f:
\n f.write(json.dumps(event) + '\\\\n')<\/p>\n
def close_connection(self, connection_info: Dict):
\n """\u5173\u95ed\u8fde\u63a5"""
\n # \u5728\u5b9e\u9645\u5e94\u7528\u4e2d，\u8fd9\u91cc\u4f1a\u5173\u95ed\u7f51\u7edc\u8fde\u63a5
\n print(f"Closing connection for request {connection_info['request_id']}")<\/p>\n
def close_connection_immediately(self, connection_info: Dict):
\n """\u7acb\u5373\u5173\u95ed\u8fde\u63a5"""
\n # \u5f3a\u5236\u5173\u95ed\u8fde\u63a5
\n print(f"Immediately closing connection for suspected attack: {connection_info['request_id']}")<\/p>\n
def get_statistics(self) -> Dict:
\n """\u83b7\u53d6\u7edf\u8ba1\u4fe1\u606f"""
\n return {
\n 'active_connections': len(self.active_connections),
\n 'total_timeouts': self.timeout_stats['total_timeouts'],
\n 'timeouts_by_stage': self.timeout_stats['by_stage'],
\n 'slow_requests_count': len(self.slow_requests),
\n 'recent_slow_requests': self.slow_requests[-10:] if self.slow_requests else []
\n }<\/p>\n
python<\/p>\n
# \u5f02\u6b65\u8d85\u65f6\u5904\u7406\u6846\u67b6
\nimport asyncio
\nfrom typing import Optional, Callable, Any, Dict
\nimport aiohttp
\nfrom aiohttp import web
\nimport async_timeout<\/p>\n
class AsyncTimeoutFramework:
\n """\u5f02\u6b65\u8d85\u65f6\u5904\u7406\u6846\u67b6"""<\/p>\n
def __init__(self, app: web.Application):
\n self.app = app
\n self.timeout_config = {
\n 'global_timeout': 120,
\n 'stage_timeouts': {
\n 'request_parsing': 5,
\n 'authentication': 10,
\n 'validation': 5,
\n 'processing': 30,
\n 'response_generation': 10
\n },
\n 'retry_policy': {
\n 'max_retries': 3,
\n 'backoff_factor': 2,
\n 'max_backoff': 60
\n }
\n }<\/p>\n
# \u4e2d\u95f4\u4ef6\u8bbe\u7f6e
\n self.setup_middleware()<\/p>\n
def setup_middleware(self):
\n """\u8bbe\u7f6e\u8d85\u65f6\u4e2d\u95f4\u4ef6"""<\/p>\n
@web.middleware
\n async def timeout_middleware(request: web.Request, handler: Callable):
\n """\u8d85\u65f6\u4e2d\u95f4\u4ef6"""
\n request_start = asyncio.get_event_loop().time()
\n request_id = request.headers.get('X-Request-ID', str(uuid.uuid4()))<\/p>\n
# \u521b\u5efa\u8d85\u65f6\u4e0a\u4e0b\u6587
\n timeout_context = {
\n 'request_id': request_id,
\n 'start_time': request_start,
\n 'current_stage': 'initial',
\n 'timeout_tasks': []
\n }<\/p>\n
request['timeout_context'] = timeout_context<\/p>\n
try:
\n # \u8bbe\u7f6e\u5168\u5c40\u8d85\u65f6
\n async with async_timeout.timeout(self.timeout_config['global_timeout']):
\n # \u6267\u884c\u5904\u7406
\n response = await self.execute_with_stage_timeouts(request, handler)
\n return response<\/p>\n
except asyncio.TimeoutError:
\n # \u5168\u5c40\u8d85\u65f6
\n elapsed = asyncio.get_event_loop().time() – request_start
\n return await self.handle_global_timeout(request, elapsed)<\/p>\n
except Exception as e:
\n # \u5176\u4ed6\u5f02\u5e38
\n return await self.handle_timeout_exception(request, e)<\/p>\n
finally:
\n # \u6e05\u7406\u8d85\u65f6\u4efb\u52a1
\n await self.cleanup_timeout_tasks(timeout_context)<\/p>\n
self.app.middlewares.append(timeout_middleware)<\/p>\n
async def execute_with_stage_timeouts(self, request: web.Request, handler: Callable):
\n """\u5206\u9636\u6bb5\u6267\u884c\u8bf7\u6c42\u5904\u7406"""
\n timeout_context = request['timeout_context']<\/p>\n
# \u9636\u6bb51: \u8bf7\u6c42\u89e3\u6790
\n timeout_context['current_stage'] = 'request_parsing'
\n await self.start_stage_timeout('request_parsing', timeout_context)<\/p>\n
# \u89e3\u6790\u8bf7\u6c42
\n try:
\n data = await request.json()
\n request['parsed_data'] = data
\n except:
\n pass # \u975eJSON\u8bf7\u6c42<\/p>\n
# \u9636\u6bb52: \u8ba4\u8bc1
\n timeout_context['current_stage'] = 'authentication'
\n await self.start_stage_timeout('authentication', timeout_context)<\/p>\n
# \u6267\u884c\u8ba4\u8bc1
\n await self.authenticate_request(request)<\/p>\n
# \u9636\u6bb53: \u9a8c\u8bc1
\n timeout_context['current_stage'] = 'validation'
\n await self.start_stage_timeout('validation', timeout_context)<\/p>\n
# \u9a8c\u8bc1\u8bf7\u6c42
\n await self.validate_request(request)<\/p>\n
# \u9636\u6bb54: \u5904\u7406
\n timeout_context['current_stage'] = 'processing'
\n await self.start_stage_timeout('processing', timeout_context)<\/p>\n
# \u6267\u884c\u4e1a\u52a1\u903b\u8f91
\n response = await handler(request)<\/p>\n
# \u9636\u6bb55: \u54cd\u5e94\u751f\u6210
\n timeout_context['current_stage'] = 'response_generation'
\n await self.start_stage_timeout('response_generation', timeout_context)<\/p>\n
# \u6dfb\u52a0\u8d85\u65f6\u76f8\u5173\u5934\u90e8
\n response.headers.update({
\n 'X-Request-Timeout-Context': json.dumps({
\n 'request_id': timeout_context['request_id'],
\n 'total_time': round(asyncio.get_event_loop().time() – timeout_context['start_time'], 3)
\n })
\n })<\/p>\n
return response<\/p>\n
async def start_stage_timeout(self, stage: str, timeout_context: Dict):
\n """\u542f\u52a8\u9636\u6bb5\u8d85\u65f6\u76d1\u63a7"""
\n timeout_seconds = self.timeout_config['stage_timeouts'].get(stage, 10)<\/p>\n
task = asyncio.create_task(
\n self.monitor_stage_timeout(stage, timeout_seconds, timeout_context)
\n )<\/p>\n
timeout_context['timeout_tasks'].append(task)<\/p>\n
async def monitor_stage_timeout(self, stage: str, timeout_seconds: float, timeout_context: Dict):
\n """\u76d1\u63a7\u9636\u6bb5\u8d85\u65f6"""
\n try:
\n await asyncio.sleep(timeout_seconds)<\/p>\n
# \u5982\u679c\u8d85\u65f6\u540e\u4ecd\u7136\u5728\u8fd9\u4e2a\u9636\u6bb5，\u89e6\u53d1\u8d85\u65f6\u5904\u7406
\n if timeout_context['current_stage'] == stage:
\n await self.handle_stage_timeout(stage, timeout_context)<\/p>\n
except asyncio.CancelledError:
\n # \u4efb\u52a1\u88ab\u53d6\u6d88，\u6b63\u5e38\u60c5\u51b5
\n pass<\/p>\n
async def handle_stage_timeout(self, stage: str, timeout_context: Dict):
\n """\u5904\u7406\u9636\u6bb5\u8d85\u65f6"""
\n # \u8bb0\u5f55\u8d85\u65f6\u4e8b\u4ef6
\n await self.log_stage_timeout(stage, timeout_context)<\/p>\n
# \u6839\u636e\u9636\u6bb5\u51b3\u5b9a\u5904\u7406\u65b9\u5f0f
\n if stage == 'processing':
\n # \u5904\u7406\u9636\u6bb5\u8d85\u65f6，\u53ef\u80fd\u9700\u8981\u4e2d\u65ad\u5904\u7406
\n await self.interrupt_processing(timeout_context)<\/p>\n
async def handle_global_timeout(self, request: web.Request, elapsed: float):
\n """\u5904\u7406\u5168\u5c40\u8d85\u65f6"""
\n timeout_context = request.get('timeout_context', {})
\n current_stage = timeout_context.get('current_stage', 'unknown')<\/p>\n
# \u521b\u5efa408\u54cd\u5e94
\n response_data = {
\n 'error': {
\n 'code': 'REQUEST_TIMEOUT',
\n 'message': 'Request processing exceeded maximum time limit',
\n 'details': {
\n 'elapsed_seconds': round(elapsed, 2),
\n 'max_timeout_seconds': self.timeout_config['global_timeout'],
\n 'stage_at_timeout': current_stage,
\n 'request_id': timeout_context.get('request_id')
\n },
\n 'suggestions': [
\n 'Simplify the request payload',
\n 'Use pagination for large datasets',
\n 'Implement asynchronous processing'
\n ]
\n }
\n }<\/p>\n
response = web.json_response(
\n response_data,
\n status=408,
\n headers={
\n 'Connection': 'close',
\n 'X-Request-Timeout': 'true',
\n 'X-Timeout-Stage': current_stage
\n }
\n )<\/p>\n
# \u8bb0\u5f55\u8d85\u65f6
\n await self.log_global_timeout(request, elapsed, current_stage)<\/p>\n
return response<\/p>\n
async def handle_timeout_exception(self, request: web.Request, exception: Exception):
\n """\u5904\u7406\u8d85\u65f6\u5f02\u5e38"""
\n # \u8bb0\u5f55\u5f02\u5e38
\n await self.log_timeout_exception(request, exception)<\/p>\n
# \u8fd4\u56de500\u9519\u8bef
\n return web.json_response(
\n {'error': 'Internal server error'},
\n status=500
\n )<\/p>\n
async def cleanup_timeout_tasks(self, timeout_context: Dict):
\n """\u6e05\u7406\u8d85\u65f6\u4efb\u52a1"""
\n for task in timeout_context.get('timeout_tasks', []):
\n if not task.done():
\n task.cancel()
\n try:
\n await task
\n except asyncio.CancelledError:
\n pass<\/p>\n
async def authenticate_request(self, request: web.Request):
\n """\u8ba4\u8bc1\u8bf7\u6c42"""
\n # \u5b9e\u9645\u8ba4\u8bc1\u903b\u8f91
\n pass<\/p>\n
async def validate_request(self, request: web.Request):
\n """\u9a8c\u8bc1\u8bf7\u6c42"""
\n # \u5b9e\u9645\u9a8c\u8bc1\u903b\u8f91
\n pass<\/p>\n
async def interrupt_processing(self, timeout_context: Dict):
\n """\u4e2d\u65ad\u5904\u7406"""
\n # \u53d1\u9001\u4e2d\u65ad\u4fe1\u53f7\u6216\u8bbe\u7f6e\u6807\u5fd7
\n timeout_context['interrupted'] = True<\/p>\n
async def log_stage_timeout(self, stage: str, timeout_context: Dict):
\n """\u8bb0\u5f55\u9636\u6bb5\u8d85\u65f6"""
\n log_entry = {
\n 'type': 'stage_timeout',
\n 'stage': stage,
\n 'request_id': timeout_context.get('request_id'),
\n 'timestamp': time.time(),
\n 'timeout_seconds': self.timeout_config['stage_timeouts'].get(stage, 10)
\n }<\/p>\n
# \u5728\u5b9e\u9645\u5e94\u7528\u4e2d，\u8fd9\u91cc\u4f1a\u8bb0\u5f55\u5230\u65e5\u5fd7\u7cfb\u7edf
\n print(f"[Stage Timeout] {log_entry}")<\/p>\n
async def log_global_timeout(self, request: web.Request, elapsed: float, stage: str):
\n """\u8bb0\u5f55\u5168\u5c40\u8d85\u65f6"""
\n log_entry = {
\n 'type': 'global_timeout',
\n 'request_id': request.headers.get('X-Request-ID'),
\n 'client_ip': request.remote,
\n 'path': request.path,
\n 'method': request.method,
\n 'elapsed_seconds': round(elapsed, 2),
\n 'stage_at_timeout': stage,
\n 'timestamp': time.time()
\n }<\/p>\n
# \u8bb0\u5f55\u5230\u6587\u4ef6
\n with open('global_timeouts.log', 'a') as f:
\n f.write(json.dumps(log_entry) + '\\\\n')<\/p>\n
async def log_timeout_exception(self, request: web.Request, exception: Exception):
\n """\u8bb0\u5f55\u8d85\u65f6\u5f02\u5e38"""
\n log_entry = {
\n 'type': 'timeout_exception',
\n 'request_id': request.headers.get('X-Request-ID'),
\n 'exception_type': type(exception).__name__,
\n 'exception_message': str(exception),
\n 'timestamp': time.time()
\n }<\/p>\n
with open('timeout_exceptions.log', 'a') as f:
\n f.write(json.dumps(log_entry) + '\\\\n')<\/p>\n
python<\/p>\n
# \u667a\u80fd\u91cd\u8bd5\u4e0e\u56de\u9000\u7b56\u7565
\nclass SmartRetryStrategy:
\n """\u667a\u80fd\u91cd\u8bd5\u7b56\u7565\u7ba1\u7406\u5668"""<\/p>\n
def __init__(self, config: Dict = None):
\n self.config = {
\n 'max_retries': 3,
\n 'base_delay': 1.0, # \u57fa\u7840\u5ef6\u8fdf（\u79d2）
\n 'max_delay': 60.0, # \u6700\u5927\u5ef6\u8fdf
\n 'jitter': 0.1, # \u6296\u52a8\u56e0\u5b50
\n 'backoff_factor': 2.0, # \u9000\u907f\u56e0\u5b50
\n 'timeout_multiplier': 1.5, # \u8d85\u65f6\u4e58\u6570
\n 'retryable_errors': [408, 429, 500, 502, 503, 504],
\n 'circuit_breaker': {
\n 'failure_threshold': 5,
\n 'reset_timeout': 60,
\n 'half_open_max_requests': 3
\n },
\n ** (config or {})
\n }<\/p>\n
self.circuit_breakers = {}
\n self.retry_stats = defaultdict(lambda: {
\n 'total_attempts': 0,
\n 'successful_retries': 0,
\n 'failed_retries': 0,
\n 'total_delay': 0.0
\n })<\/p>\n
async def execute_with_retry(self, request_func: Callable, request_data: Dict,
\n context: Dict = None) -> Any:
\n """\u6267\u884c\u5e26\u91cd\u8bd5\u7684\u8bf7\u6c42"""
\n context = context or {}
\n retry_count = 0
\n last_exception = None<\/p>\n
while retry_count <= self.config['max_retries']:
\n attempt_start = time.time()<\/p>\n
# \u68c0\u67e5\u7194\u65ad\u5668
\n circuit_key = self.get_circuit_key(request_data)
\n if not self.allow_request(circuit_key):
\n raise CircuitBreakerOpenError(f"Circuit breaker open for {circuit_key}")<\/p>\n
try:
\n # \u8ba1\u7b97\u672c\u6b21\u5c1d\u8bd5\u7684\u8d85\u65f6\u65f6\u95f4
\n timeout = self.calculate_timeout(retry_count)<\/p>\n
# \u6267\u884c\u8bf7\u6c42
\n async with async_timeout.timeout(timeout):
\n result = await request_func(request_data)<\/p>\n
# \u8bf7\u6c42\u6210\u529f
\n if retry_count > 0:
\n self.record_successful_retry(circuit_key, retry_count)
\n self.reset_circuit_breaker(circuit_key)<\/p>\n
return result<\/p>\n
except asyncio.TimeoutError:
\n # \u8d85\u65f6\u5f02\u5e38
\n last_exception = TimeoutError(f"Request timeout after {timeout} seconds")
\n await self.handle_timeout(circuit_key, retry_count)<\/p>\n
except Exception as e:
\n # \u5176\u4ed6\u5f02\u5e38
\n last_exception = e
\n if not self.should_retry(e):
\n raise e
\n await self.handle_error(circuit_key, e, retry_count)<\/p>\n
# \u51c6\u5907\u91cd\u8bd5
\n retry_count += 1<\/p>\n
if retry_count <= self.config['max_retries']:
\n # \u8ba1\u7b97\u5ef6\u8fdf
\n delay = self.calculate_delay(retry_count)
\n self.retry_stats[circuit_key]['total_delay'] += delay<\/p>\n
# \u8bb0\u5f55\u91cd\u8bd5
\n await self.log_retry_attempt(request_data, retry_count, delay, last_exception)<\/p>\n
# \u7b49\u5f85\u5ef6\u8fdf
\n await asyncio.sleep(delay)<\/p>\n
# \u6240\u6709\u91cd\u8bd5\u90fd\u5931\u8d25
\n raise MaxRetriesExceededError(
\n f"Max retries ({self.config['max_retries']}) exceeded",
\n last_exception=last_exception
\n )<\/p>\n
def get_circuit_key(self, request_data: Dict) -> str:
\n """\u83b7\u53d6\u7194\u65ad\u5668\u952e"""
\n # \u57fa\u4e8e\u7aef\u70b9\u548c\u65b9\u6cd5\u521b\u5efa\u952e
\n endpoint = request_data.get('endpoint', 'unknown')
\n method = request_data.get('method', 'GET')
\n return f"{method}:{endpoint}"<\/p>\n
def allow_request(self, circuit_key: str) -> bool:
\n """\u68c0\u67e5\u662f\u5426\u5141\u8bb8\u8bf7\u6c42"""
\n if circuit_key not in self.circuit_breakers:
\n return True<\/p>\n
cb = self.circuit_breakers[circuit_key]<\/p>\n
if cb['state'] == 'open':
\n # \u68c0\u67e5\u662f\u5426\u5e94\u8be5\u8fdb\u5165\u534a\u5f00\u72b6\u6001
\n if time.time() – cb['opened_at'] >= self.config['circuit_breaker']['reset_timeout']:
\n cb['state'] = 'half_open'
\n cb['half_open_attempts'] = 0
\n return True
\n return False<\/p>\n
elif cb['state'] == 'half_open':
\n # \u9650\u5236\u534a\u5f00\u72b6\u6001\u7684\u5e76\u53d1\u8bf7\u6c42
\n if cb['half_open_attempts'] >= self.config['circuit_breaker']['half_open_max_requests']:
\n return False
\n cb['half_open_attempts'] += 1
\n return True<\/p>\n
return True # closed\u72b6\u6001<\/p>\n
def calculate_timeout(self, retry_count: int) -> float:
\n """\u8ba1\u7b97\u8d85\u65f6\u65f6\u95f4"""
\n # \u6307\u6570\u9000\u907f：\u6bcf\u6b21\u91cd\u8bd5\u589e\u52a0\u8d85\u65f6\u65f6\u95f4
\n base_timeout = 30.0 # \u57fa\u7840\u8d85\u65f630\u79d2
\n timeout = base_timeout * (self.config['timeout_multiplier'] ** retry_count)
\n return min(timeout, 300.0) # \u6700\u59275\u5206\u949f<\/p>\n
def calculate_delay(self, retry_count: int) -> float:
\n """\u8ba1\u7b97\u91cd\u8bd5\u5ef6\u8fdf"""
\n # \u6307\u6570\u9000\u907f\u7b97\u6cd5
\n delay = self.config['base_delay'] * (self.config['backoff_factor'] ** (retry_count – 1))<\/p>\n
# \u6dfb\u52a0\u968f\u673a\u6296\u52a8
\n jitter = random.uniform(1 – self.config['jitter'], 1 + self.config['jitter'])
\n delay *= jitter<\/p>\n
# \u9650\u5236\u6700\u5927\u5ef6\u8fdf
\n return min(delay, self.config['max_delay'])<\/p>\n
def should_retry(self, exception: Exception) -> bool:
\n """\u68c0\u67e5\u662f\u5426\u5e94\u8be5\u91cd\u8bd5"""
\n # \u68c0\u67e5HTTP\u72b6\u6001\u7801
\n if hasattr(exception, 'status_code'):
\n return exception.status_code in self.config['retryable_errors']<\/p>\n
# \u68c0\u67e5\u5f02\u5e38\u7c7b\u578b
\n retryable_exceptions = [
\n TimeoutError,
\n ConnectionError,
\n asyncio.TimeoutError
\n ]<\/p>\n
for exc_type in retryable_exceptions:
\n if isinstance(exception, exc_type):
\n return True<\/p>\n
return False<\/p>\n
async def handle_timeout(self, circuit_key: str, retry_count: int):
\n """\u5904\u7406\u8d85\u65f6"""
\n # \u8bb0\u5f55\u8d85\u65f6
\n self.record_failure(circuit_key)<\/p>\n
# \u68c0\u67e5\u662f\u5426\u5e94\u8be5\u6253\u5f00\u7194\u65ad\u5668
\n if self.should_open_circuit(circuit_key):
\n self.open_circuit_breaker(circuit_key)<\/p>\n
async def handle_error(self, circuit_key: str, error: Exception, retry_count: int):
\n """\u5904\u7406\u9519\u8bef"""
\n # \u8bb0\u5f55\u9519\u8bef
\n self.record_failure(circuit_key)<\/p>\n
# \u68c0\u67e5\u662f\u5426\u5e94\u8be5\u6253\u5f00\u7194\u65ad\u5668
\n if self.should_open_circuit(circuit_key):
\n self.open_circuit_breaker(circuit_key)<\/p>\n
def record_failure(self, circuit_key: str):
\n """\u8bb0\u5f55\u5931\u8d25"""
\n if circuit_key not in self.circuit_breakers:
\n self.circuit_breakers[circuit_key] = {
\n 'state': 'closed',
\n 'failure_count': 0,
\n 'success_count': 0,
\n 'last_failure': None,
\n 'opened_at': None
\n }<\/p>\n
cb = self.circuit_breakers[circuit_key]
\n cb['failure_count'] += 1
\n cb['last_failure'] = time.time()<\/p>\n
# \u68c0\u67e5\u5931\u8d25\u9608\u503c
\n if (cb['state'] == 'closed' and
\n cb['failure_count'] >= self.config['circuit_breaker']['failure_threshold']):
\n self.open_circuit_breaker(circuit_key)<\/p>\n
def record_successful_retry(self, circuit_key: str, retry_count: int):
\n """\u8bb0\u5f55\u6210\u529f\u91cd\u8bd5"""
\n self.retry_stats[circuit_key]['successful_retries'] += 1
\n self.retry_stats[circuit_key]['total_attempts'] += retry_count + 1<\/p>\n
# \u66f4\u65b0\u7194\u65ad\u5668
\n if circuit_key in self.circuit_breakers:
\n cb = self.circuit_breakers[circuit_key]
\n cb['success_count'] += 1<\/p>\n
# \u5982\u679c\u5728\u534a\u5f00\u72b6\u6001\u6210\u529f，\u5173\u95ed\u7194\u65ad\u5668
\n if cb['state'] == 'half_open' and cb['success_count'] >= 3:
\n self.close_circuit_breaker(circuit_key)<\/p>\n
def should_open_circuit(self, circuit_key: str) -> bool:
\n """\u68c0\u67e5\u662f\u5426\u5e94\u8be5\u6253\u5f00\u7194\u65ad\u5668"""
\n if circuit_key not in self.circuit_breakers:
\n return False<\/p>\n
cb = self.circuit_breakers[circuit_key]<\/p>\n
# \u68c0\u67e5\u5931\u8d25\u7387
\n total_requests = cb['failure_count'] + cb['success_count']
\n if total_requests < 10: # \u9700\u8981\u6700\u5c0f\u6837\u672c\u91cf
\n return False<\/p>\n
failure_rate = cb['failure_count'] \/ total_requests
\n return failure_rate > 0.5 # \u5931\u8d25\u7387\u8d85\u8fc750%<\/p>\n
def open_circuit_breaker(self, circuit_key: str):
\n """\u6253\u5f00\u7194\u65ad\u5668"""
\n cb = self.circuit_breakers[circuit_key]
\n cb['state'] = 'open'
\n cb['opened_at'] = time.time()<\/p>\n
# \u8bb0\u5f55\u7194\u65ad\u4e8b\u4ef6
\n self.log_circuit_event(circuit_key, 'opened')<\/p>\n
def close_circuit_breaker(self, circuit_key: str):
\n """\u5173\u95ed\u7194\u65ad\u5668"""
\n cb = self.circuit_breakers[circuit_key]
\n cb['state'] = 'closed'
\n cb['failure_count'] = 0
\n cb['success_count'] = 0<\/p>\n
# \u8bb0\u5f55\u7194\u65ad\u4e8b\u4ef6
\n self.log_circuit_event(circuit_key, 'closed')<\/p>\n
def reset_circuit_breaker(self, circuit_key: str):
\n """\u91cd\u7f6e\u7194\u65ad\u5668"""
\n if circuit_key in self.circuit_breakers:
\n cb = self.circuit_breakers[circuit_key]
\n if cb['state'] == 'closed':
\n # \u9010\u6e10\u51cf\u5c11\u5931\u8d25\u8ba1\u6570（\u8870\u51cf）
\n cb['failure_count'] = max(0, cb['failure_count'] – 1)<\/p>\n
async def log_retry_attempt(self, request_data: Dict, retry_count: int,
\n delay: float, exception: Exception):
\n """\u8bb0\u5f55\u91cd\u8bd5\u5c1d\u8bd5"""
\n log_entry = {
\n 'timestamp': time.time(),
\n 'request_id': request_data.get('request_id'),
\n 'endpoint': request_data.get('endpoint'),
\n 'method': request_data.get('method'),
\n 'retry_count': retry_count,
\n 'delay_seconds': round(delay, 2),
\n 'exception_type': type(exception).__name__,
\n 'exception_message': str(exception)[:200]
\n }<\/p>\n
# \u5728\u5b9e\u9645\u5e94\u7528\u4e2d，\u8fd9\u91cc\u4f1a\u8bb0\u5f55\u5230\u65e5\u5fd7\u7cfb\u7edf
\n print(f"[Retry Attempt] {log_entry}")<\/p>\n
def log_circuit_event(self, circuit_key: str, event: str):
\n """\u8bb0\u5f55\u7194\u65ad\u4e8b\u4ef6"""
\n log_entry = {
\n 'timestamp': time.time(),
\n 'circuit_key': circuit_key,
\n 'event': event,
\n 'state': self.circuit_breakers[circuit_key]['state']
\n }<\/p>\n
with open('circuit_breaker_events.log', 'a') as f:
\n f.write(json.dumps(log_entry) + '\\\\n')<\/p>\n
def get_retry_statistics(self) -> Dict:
\n """\u83b7\u53d6\u91cd\u8bd5\u7edf\u8ba1"""
\n stats = {
\n 'circuit_breakers': {},
\n 'retry_stats': dict(self.retry_stats),
\n 'summary': {
\n 'total_circuits': len(self.circuit_breakers),
\n 'open_circuits': sum(1 for cb in self.circuit_breakers.values()
\n if cb['state'] == 'open'),
\n 'half_open_circuits': sum(1 for cb in self.circuit_breakers.values()
\n if cb['state'] == 'half_open')
\n }
\n }<\/p>\n
for key, cb in self.circuit_breakers.items():
\n stats['circuit_breakers'][key] = {
\n 'state': cb['state'],
\n 'failure_count': cb['failure_count'],
\n 'success_count': cb['success_count']
\n }<\/p>\n
return stats<\/p>\n
class CircuitBreakerOpenError(Exception):
\n """\u7194\u65ad\u5668\u6253\u5f00\u5f02\u5e38"""
\n pass<\/p>\n
class MaxRetriesExceededError(Exception):
\n """\u6700\u5927\u91cd\u8bd5\u6b21\u6570\u8d85\u51fa\u5f02\u5e38"""
\n def __init__(self, message, last_exception=None):
\n super().__init__(message)
\n self.last_exception = last_exception<\/p>\n
javascript<\/p>\n
\/\/ \u5ba2\u6237\u7aef\u81ea\u9002\u5e94\u91cd\u8bd5\u7b56\u7565
\nclass AdaptiveRetryClient {
\n constructor(config = {}) {
\n this.config = {
\n maxRetries: 3,
\n baseDelay: 1000,
\n maxDelay: 30000,
\n timeout: 30000,
\n timeoutMultiplier: 1.5,
\n backoffFactor: 2,
\n jitter: 0.2,
\n circuitBreaker: {
\n failureThreshold: 5,
\n resetTimeout: 60000,
\n halfOpenMaxRequests: 2
\n },
\n fallbackStrategies: {
\n timeout: 'return_cached',
\n network_error: 'retry_with_exponential_backoff',
\n server_error: 'use_alternative_endpoint'
\n },
\n …config
\n };<\/p>\n
this.circuitBreakers = new Map();
\n this.requestHistory = new Map();
\n this.fallbackCache = new Map();
\n this.metrics = {
\n totalRequests: 0,
\n successfulRequests: 0,
\n failedRequests: 0,
\n timeouts: 0,
\n retries: 0
\n };<\/p>\n
\/\/ \u7f51\u7edc\u8d28\u91cf\u68c0\u6d4b
\n this.networkQuality = {
\n latency: 0,
\n throughput: 0,
\n reliability: 1.0
\n };<\/p>\n
\/\/ \u521d\u59cb\u5316\u7f51\u7edc\u76d1\u63a7
\n this.initNetworkMonitoring();
\n }<\/p>\n
async fetchWithRetry(url, options = {}) {
\n const requestId = this.generateRequestId();
\n const startTime = Date.now();<\/p>\n
this.metrics.totalRequests++;<\/p>\n
\/\/ \u521b\u5efa\u8bf7\u6c42\u4e0a\u4e0b\u6587
\n const context = {
\n requestId,
\n url,
\n method: options.method || 'GET',
\n startTime,
\n attempt: 0,
\n delays: [],
\n errors: []
\n };<\/p>\n
\/\/ \u68c0\u67e5\u7194\u65ad\u5668
\n const circuitKey = this.getCircuitKey(url, options.method);
\n if (!this.allowRequest(circuitKey)) {
\n return await this.executeFallback('circuit_breaker_open', context, options);
\n }<\/p>\n
\/\/ \u6267\u884c\u5e26\u91cd\u8bd5\u7684\u8bf7\u6c42
\n try {
\n const result = await this.executeWithAdaptiveRetry(context, options);<\/p>\n
\/\/ \u8bf7\u6c42\u6210\u529f
\n this.metrics.successfulRequests++;
\n this.recordSuccess(circuitKey);<\/p>\n
\/\/ \u66f4\u65b0\u7f51\u7edc\u8d28\u91cf\u6307\u6807
\n this.updateNetworkQuality(context, true);<\/p>\n
return result;<\/p>\n
} catch (error) {
\n \/\/ \u8bf7\u6c42\u5931\u8d25
\n this.metrics.failedRequests++;<\/p>\n
if (error.name === 'TimeoutError') {
\n this.metrics.timeouts++;
\n }<\/p>\n
\/\/ \u8bb0\u5f55\u5931\u8d25
\n this.recordFailure(circuitKey, error);<\/p>\n
\/\/ \u66f4\u65b0\u7f51\u7edc\u8d28\u91cf\u6307\u6807
\n this.updateNetworkQuality(context, false);<\/p>\n
\/\/ \u6267\u884c\u964d\u7ea7\u7b56\u7565
\n return await this.executeFallback(error.name, context, options, error);
\n }
\n }<\/p>\n
async executeWithAdaptiveRetry(context, options) {
\n let lastError;<\/p>\n
for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
\n context.attempt = attempt;<\/p>\n
try {
\n \/\/ \u8ba1\u7b97\u672c\u6b21\u5c1d\u8bd5\u7684\u8d85\u65f6\u65f6\u95f4
\n const timeout = this.calculateTimeout(attempt);<\/p>\n
\/\/ \u521b\u5efa\u5e26\u8d85\u65f6\u7684fetch\u8bf7\u6c42
\n const controller = new AbortController();
\n const timeoutId = setTimeout(() => controller.abort(), timeout);<\/p>\n
const fetchOptions = {
\n …options,
\n signal: controller.signal
\n };<\/p>\n
\/\/ \u6267\u884c\u8bf7\u6c42
\n const startAttempt = Date.now();
\n const response = await fetch(context.url, fetchOptions);
\n const attemptDuration = Date.now() – startAttempt;<\/p>\n
clearTimeout(timeoutId);<\/p>\n
\/\/ \u68c0\u67e5HTTP\u72b6\u6001\u7801
\n if (!response.ok) {
\n const error = new Error(`HTTP ${response.status}`);
\n error.statusCode = response.status;<\/p>\n
\/\/ \u51b3\u5b9a\u662f\u5426\u91cd\u8bd5
\n if (this.shouldRetry(error, attempt)) {
\n lastError = error;
\n context.errors.push(error);
\n await this.handleRetry(context, attempt, error);
\n continue;
\n }<\/p>\n
throw error;
\n }<\/p>\n
\/\/ \u8bf7\u6c42\u6210\u529f
\n if (attempt > 0) {
\n this.metrics.retries++;
\n }<\/p>\n
return response;<\/p>\n
} catch (error) {
\n lastError = error;
\n context.errors.push(error);<\/p>\n
\/\/ \u68c0\u67e5\u662f\u5426\u5e94\u8be5\u91cd\u8bd5
\n if (attempt < this.config.maxRetries && this.shouldRetry(error, attempt)) {
\n await this.handleRetry(context, attempt, error);
\n continue;
\n }<\/p>\n
\/\/ \u4e0d\u518d\u91cd\u8bd5，\u629b\u51fa\u9519\u8bef
\n break;
\n }
\n }<\/p>\n
throw lastError || new Error('Request failed');
\n }<\/p>\n
calculateTimeout(attempt) {
\n \/\/ \u81ea\u9002\u5e94\u8d85\u65f6：\u57fa\u4e8e\u5386\u53f2\u54cd\u5e94\u65f6\u95f4
\n const baseTimeout = this.config.timeout;<\/p>\n
\/\/ \u8003\u8651\u7f51\u7edc\u8d28\u91cf
\n const networkFactor = Math.max(0.5, Math.min(2.0,
\n this.networkQuality.latency \/ 100)); \/\/ \u5047\u8bbe\u57fa\u51c6\u5ef6\u8fdf100ms<\/p>\n
\/\/ \u6307\u6570\u9000\u907f
\n const backoffTimeout = baseTimeout *
\n Math.pow(this.config.timeoutMultiplier, attempt) *
\n networkFactor;<\/p>\n
return Math.min(backoffTimeout, this.config.maxDelay * 2);
\n }<\/p>\n
calculateDelay(attempt, error) {
\n \/\/ \u57fa\u7840\u9000\u907f
\n let delay = this.config.baseDelay * Math.pow(this.config.backoffFactor, attempt);<\/p>\n
\/\/ \u6dfb\u52a0\u6296\u52a8
\n const jitter = 1 + (Math.random() * 2 – 1) * this.config.jitter;
\n delay *= jitter;<\/p>\n
\/\/ \u57fa\u4e8e\u9519\u8bef\u7c7b\u578b\u8c03\u6574
\n if (error && error.name === 'TimeoutError') {
\n delay *= 1.5; \/\/ \u8d85\u65f6\u9519\u8bef\u589e\u52a0\u5ef6\u8fdf
\n }<\/p>\n
\/\/ \u57fa\u4e8e\u7f51\u7edc\u8d28\u91cf\u8c03\u6574
\n if (this.networkQuality.reliability < 0.5) {
\n delay *= 2; \/\/ \u7f51\u7edc\u4e0d\u53ef\u9760\u65f6\u589e\u52a0\u5ef6\u8fdf
\n }<\/p>\n
return Math.min(delay, this.config.maxDelay);
\n }<\/p>\n
shouldRetry(error, attempt) {
\n \/\/ \u57fa\u4e8e\u9519\u8bef\u7c7b\u578b\u51b3\u5b9a\u662f\u5426\u91cd\u8bd5
\n const retryableErrors = [
\n 'TimeoutError',
\n 'TypeError', \/\/ \u7f51\u7edc\u9519\u8bef
\n 'AbortError'
\n ];<\/p>\n
if (retryableErrors.includes(error.name)) {
\n return true;
\n }<\/p>\n
\/\/ \u57fa\u4e8eHTTP\u72b6\u6001\u7801\u51b3\u5b9a\u662f\u5426\u91cd\u8bd5
\n if (error.statusCode) {
\n const retryableStatusCodes = [408, 429, 500, 502, 503, 504];
\n return retryableStatusCodes.includes(error.statusCode);
\n }<\/p>\n
\/\/ \u57fa\u4e8e\u5c1d\u8bd5\u6b21\u6570\u51b3\u5b9a\u662f\u5426\u91cd\u8bd5
\n if (attempt >= this.config.maxRetries) {
\n return false;
\n }<\/p>\n
\/\/ \u9ed8\u8ba4\u4e0d\u91cd\u8bd5
\n return false;
\n }<\/p>\n
async handleRetry(context, attempt, error) {
\n \/\/ \u8ba1\u7b97\u5ef6\u8fdf
\n const delay = this.calculateDelay(attempt, error);
\n context.delays.push(delay);<\/p>\n
\/\/ \u8bb0\u5f55\u91cd\u8bd5
\n this.logRetryAttempt(context, attempt, delay, error);<\/p>\n
\/\/ \u7b49\u5f85\u5ef6\u8fdf
\n await this.sleep(delay);
\n }<\/p>\n
async executeFallback(failureType, context, options, error) {
\n const fallbackStrategy = this.config.fallbackStrategies[failureType] ||
\n this.config.fallbackStrategies.default;<\/p>\n
switch (fallbackStrategy) {
\n case 'return_cached':
\n return this.returnCachedResponse(context.url, options);<\/p>\n
case 'retry_with_exponential_backoff':
\n \/\/ \u5df2\u5728\u4e0a\u5c42\u5904\u7406
\n throw error;<\/p>\n
case 'use_alternative_endpoint':
\n return this.useAlternativeEndpoint(context.url, options);<\/p>\n
case 'return_degraded_response':
\n return this.returnDegradedResponse(context, options);<\/p>\n
case 'notify_user':
\n return this.notifyUserAndFail(context, error);<\/p>\n
default:
\n throw error;
\n }
\n }<\/p>\n
async returnCachedResponse(url, options) {
\n \/\/ \u68c0\u67e5\u7f13\u5b58
\n const cacheKey = this.getCacheKey(url, options);
\n const cached = this.fallbackCache.get(cacheKey);<\/p>\n
if (cached && Date.now() – cached.timestamp < 300000) { \/\/ 5\u5206\u949f\u7f13\u5b58
\n console.log(`Using cached response for ${url}`);<\/p>\n
\/\/ \u521b\u5efa\u6a21\u62df\u54cd\u5e94
\n return new Response(JSON.stringify(cached.data), {
\n status: 200,
\n headers: {
\n 'Content-Type': 'application\/json',
\n 'X-Cached-Response': 'true',
\n 'X-Cache-Age': Math.round((Date.now() – cached.timestamp) \/ 1000) + 's'
\n }
\n });
\n }<\/p>\n
throw new Error('No cached response available');
\n }<\/p>\n
async useAlternativeEndpoint(originalUrl, options) {
\n \/\/ \u751f\u6210\u66ff\u4ee3\u7aef\u70b9
\n const alternativeUrl = this.generateAlternativeUrl(originalUrl);<\/p>\n
if (alternativeUrl && alternativeUrl !== originalUrl) {
\n console.log(`Trying alternative endpoint: ${alternativeUrl}`);<\/p>\n
\/\/ \u4f7f\u7528\u66ff\u4ee3\u7aef\u70b9\u91cd\u8bd5（\u6700\u591a\u4e00\u6b21）
\n return this.fetchWithRetry(alternativeUrl, {
\n …options,
\n headers: {
\n …options.headers,
\n 'X-Original-URL': originalUrl
\n }
\n });
\n }<\/p>\n
throw new Error('No alternative endpoint available');
\n }<\/p>\n
generateAlternativeUrl(url) {
\n const urlObj = new URL(url);<\/p>\n
\/\/ \u5c1d\u8bd5\u4e0d\u540c\u7684\u7b56\u7565
\n const strategies = [
\n \/\/ 1. \u4f7f\u7528\u5907\u7528\u57df\u540d
\n () => {
\n if (urlObj.hostname === 'api.example.com') {
\n urlObj.hostname = 'api-backup.example.com';
\n return urlObj.toString();
\n }
\n return null;
\n },<\/p>\n
\/\/ 2. \u4f7f\u7528\u4e0d\u540c\u7aef\u53e3
\n () => {
\n if (!urlObj.port) {
\n urlObj.port = '8080';
\n return urlObj.toString();
\n }
\n return null;
\n },<\/p>\n
\/\/ 3. \u4f7f\u7528\u4e0d\u540cAPI\u7248\u672c
\n () => {
\n if (urlObj.pathname.includes('\/v1\/')) {
\n return urlObj.toString().replace('\/v1\/', '\/v2\/');
\n }
\n return null;
\n },<\/p>\n
\/\/ 4. \u4f7f\u7528HTTP\u4ee3\u66ffHTTPS（\u4ec5\u9650\u5f00\u53d1\u73af\u5883）
\n () => {
\n if (urlObj.protocol === 'https:' && window.location.hostname === 'localhost') {
\n urlObj.protocol = 'http:';
\n return urlObj.toString();
\n }
\n return null;
\n }
\n ];<\/p>\n
for (const strategy of strategies) {
\n const result = strategy();
\n if (result) {
\n return result;
\n }
\n }<\/p>\n
return null;
\n }<\/p>\n
returnDegradedResponse(context, options) {
\n \/\/ \u8fd4\u56de\u964d\u7ea7\u54cd\u5e94
\n const degradedData = {
\n data: null,
\n warning: {
\n code: 'DEGRADED_SERVICE',
\n message: 'Service is temporarily degraded. Some features may be unavailable.',
\n request_id: context.requestId,
\n original_url: context.url
\n },
\n metadata: {
\n degraded: true,
\n timestamp: new Date().toISOString(),
\n attempts: context.attempt
\n }
\n };<\/p>\n
return new Response(JSON.stringify(degradedData), {
\n status: 200,
\n headers: {
\n 'Content-Type': 'application\/json',
\n 'X-Degraded-Service': 'true'
\n }
\n });
\n }<\/p>\n
notifyUserAndFail(context, error) {
\n \/\/ \u663e\u793a\u7528\u6237\u901a\u77e5
\n this.showUserNotification({
\n type: 'error',
\n title: 'Connection Error',
\n message: 'Unable to connect to the server. Please check your connection and try again.',
\n details: {
\n requestId: context.requestId,
\n url: context.url,
\n error: error.message
\n }
\n });<\/p>\n
throw error;
\n }<\/p>\n
\/\/ \u7194\u65ad\u5668\u76f8\u5173\u65b9\u6cd5
\n getCircuitKey(url, method) {
\n const urlObj = new URL(url);
\n return `${method}:${urlObj.hostname}:${urlObj.pathname.split('\/')[1] || ''}`;
\n }<\/p>\n
allowRequest(circuitKey) {
\n if (!this.circuitBreakers.has(circuitKey)) {
\n this.circuitBreakers.set(circuitKey, {
\n state: 'closed',
\n failureCount: 0,
\n successCount: 0,
\n lastFailure: null,
\n openedAt: null,
\n halfOpenAttempts: 0
\n });
\n return true;
\n }<\/p>\n
const cb = this.circuitBreakers.get(circuitKey);<\/p>\n
if (cb.state === 'open') {
\n \/\/ \u68c0\u67e5\u662f\u5426\u5e94\u8be5\u8fdb\u5165\u534a\u5f00\u72b6\u6001
\n if (Date.now() – cb.openedAt >= this.config.circuitBreaker.resetTimeout) {
\n cb.state = 'half_open';
\n cb.halfOpenAttempts = 0;
\n return true;
\n }
\n return false;
\n }<\/p>\n
if (cb.state === 'half_open') {
\n if (cb.halfOpenAttempts >= this.config.circuitBreaker.halfOpenMaxRequests) {
\n return false;
\n }
\n cb.halfOpenAttempts++;
\n return true;
\n }<\/p>\n
return true; \/\/ closed\u72b6\u6001
\n }<\/p>\n
recordSuccess(circuitKey) {
\n const cb = this.circuitBreakers.get(circuitKey);
\n if (cb) {
\n cb.successCount++;
\n cb.failureCount = Math.max(0, cb.failureCount – 1); \/\/ \u8870\u51cf\u5931\u8d25\u8ba1\u6570<\/p>\n
if (cb.state === 'half_open' && cb.successCount >= 3) {
\n cb.state = 'closed';
\n cb.failureCount = 0;
\n cb.successCount = 0;
\n }
\n }
\n }<\/p>\n
recordFailure(circuitKey, error) {
\n const cb = this.circuitBreakers.get(circuitKey);
\n if (cb) {
\n cb.failureCount++;
\n cb.lastFailure = Date.now();<\/p>\n
\/\/ \u68c0\u67e5\u662f\u5426\u5e94\u8be5\u6253\u5f00\u7194\u65ad\u5668
\n if (cb.state === 'closed' &&
\n cb.failureCount >= this.config.circuitBreaker.failureThreshold) {
\n cb.state = 'open';
\n cb.openedAt = Date.now();
\n this.logCircuitEvent(circuitKey, 'opened', error);
\n }
\n }
\n }<\/p>\n
\/\/ \u7f51\u7edc\u76d1\u63a7
\n initNetworkMonitoring() {
\n \/\/ \u5b9a\u671f\u68c0\u67e5\u7f51\u7edc\u8d28\u91cf
\n setInterval(() => this.checkNetworkQuality(), 30000);<\/p>\n
\/\/ \u76d1\u542c\u5728\u7ebf\/\u79bb\u7ebf\u4e8b\u4ef6
\n window.addEventListener('online', () => this.handleNetworkOnline());
\n window.addEventListener('offline', () => this.handleNetworkOffline());
\n }<\/p>\n
async checkNetworkQuality() {
\n try {
\n \/\/ \u6d4b\u91cf\u5230\u5df2\u77e5\u670d\u52a1\u5668\u7684\u5ef6\u8fdf
\n const latency = await this.measureLatency();<\/p>\n
\/\/ \u6d4b\u91cf\u541e\u5410\u91cf
\n const throughput = await this.measureThroughput();<\/p>\n
\/\/ \u8ba1\u7b97\u53ef\u9760\u6027
\n const recentRequests = Array.from(this.requestHistory.values())
\n .slice(-20); \/\/ \u6700\u8fd120\u4e2a\u8bf7\u6c42<\/p>\n
const successfulRequests = recentRequests.filter(r => r.success);
\n const reliability = recentRequests.length > 0 ?
\n successfulRequests.length \/ recentRequests.length : 1.0;<\/p>\n
this.networkQuality = {
\n latency,
\n throughput,
\n reliability
\n };<\/p>\n
console.log(`Network quality updated:`, this.networkQuality);<\/p>\n
} catch (error) {
\n console.warn('Network quality check failed:', error);
\n }
\n }<\/p>\n
async measureLatency() {
\n const startTime = Date.now();
\n try {
\n await fetch('\/ping', {
\n method: 'HEAD',
\n cache: 'no-store'
\n });
\n return Date.now() – startTime;
\n } catch {
\n return 1000; \/\/ \u9ed8\u8ba4\u9ad8\u5ef6\u8fdf
\n }
\n }<\/p>\n
async measureThroughput() {
\n \/\/ \u7b80\u5355\u6d4b\u8bd5：\u4e0b\u8f7d\u5c0f\u6587\u4ef6\u6d4b\u91cf\u901f\u5ea6
\n const testSize = 10000; \/\/ 10KB
\n const startTime = Date.now();<\/p>\n
try {
\n const response = await fetch(`\/test-data?size=${testSize}`);
\n const blob = await response.blob();
\n const duration = Date.now() – startTime;<\/p>\n
return duration > 0 ? (testSize * 8) \/ (duration \/ 1000) : 0; \/\/ bps
\n } catch {
\n return 0;
\n }
\n }<\/p>\n
updateNetworkQuality(context, success) {
\n \/\/ \u8bb0\u5f55\u8bf7\u6c42\u5386\u53f2
\n this.requestHistory.set(context.requestId, {
\n url: context.url,
\n success,
\n duration: Date.now() – context.startTime,
\n timestamp: Date.now(),
\n attempts: context.attempt
\n });<\/p>\n
\/\/ \u4fdd\u6301\u5386\u53f2\u8bb0\u5f55\u5927\u5c0f
\n if (this.requestHistory.size > 100) {
\n const oldestKey = this.requestHistory.keys().next().value;
\n this.requestHistory.delete(oldestKey);
\n }
\n }<\/p>\n
handleNetworkOnline() {
\n console.log('Network came online, resetting circuit breakers');
\n \/\/ \u91cd\u7f6e\u6240\u6709\u7194\u65ad\u5668
\n for (const cb of this.circuitBreakers.values()) {
\n if (cb.state === 'open') {
\n cb.state = 'half_open';
\n cb.halfOpenAttempts = 0;
\n }
\n }
\n }<\/p>\n
handleNetworkOffline() {
\n console.log('Network went offline');
\n this.networkQuality.reliability = 0;
\n }<\/p>\n
\/\/ \u5de5\u5177\u65b9\u6cd5
\n generateRequestId() {
\n return `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
\n }<\/p>\n
getCacheKey(url, options) {
\n const urlObj = new URL(url);
\n return `${urlObj.pathname}?${urlObj.searchParams.toString()}:${options.method || 'GET'}`;
\n }<\/p>\n
sleep(ms) {
\n return new Promise(resolve => setTimeout(resolve, ms));
\n }<\/p>\n
logRetryAttempt(context, attempt, delay, error) {
\n console.log(`Retry attempt ${attempt + 1} for ${context.url}, delay: ${delay}ms`, error);
\n }<\/p>\n
logCircuitEvent(circuitKey, event, error) {
\n console.log(`Circuit breaker ${circuitKey} ${event}`, error);
\n }<\/p>\n
showUserNotification(notification) {
\n \/\/ \u5728\u5b9e\u9645\u5e94\u7528\u4e2d，\u8fd9\u91cc\u4f1a\u663e\u793aUI\u901a\u77e5
\n console.log('User notification:', notification);
\n }<\/p>\n
getMetrics() {
\n return {
\n …this.metrics,
\n circuitBreakers: {
\n total: this.circuitBreakers.size,
\n open: Array.from(this.circuitBreakers.values()).filter(cb => cb.state === 'open').length,
\n halfOpen: Array.from(this.circuitBreakers.values()).filter(cb => cb.state === 'half_open').length
\n },
\n networkQuality: this.networkQuality
\n };
\n }
\n}<\/p>\n
\/\/ \u4f7f\u7528\u793a\u4f8b
\nconst client = new AdaptiveRetryClient({
\n maxRetries: 3,
\n timeout: 10000,
\n fallbackStrategies: {
\n timeout: 'return_cached',
\n network_error: 'use_alternative_endpoint',
\n server_error: 'return_degraded_response'
\n }
\n});<\/p>\n
\/\/ \u53d1\u8d77\u8bf7\u6c42
\nasync function fetchUserData(userId) {
\n try {
\n const response = await client.fetchWithRetry(`\/api\/users\/${userId}`, {
\n headers: {
\n 'Authorization': `Bearer ${token}`
\n }
\n });<\/p>\n
if (response.headers.get('X-Degraded-Service')) {
\n \/\/ \u5904\u7406\u964d\u7ea7\u54cd\u5e94
\n return handleDegradedResponse(await response.json());
\n }<\/p>\n
return await response.json();<\/p>\n
} catch (error) {
\n console.error('Failed to fetch user data:', error);
\n return null;
\n }
\n}<\/p>\n
python<\/p>\n
# \u8d85\u65f6\u76d1\u63a7\u4e0e\u6839\u56e0\u5206\u6790\u7cfb\u7edf
\nfrom datetime import datetime, timedelta
\nfrom collections import defaultdict, deque
\nimport statistics
\nfrom typing import Dict, List, Optional, Tuple
\nimport numpy as np
\nfrom scipy import stats<\/p>\n
class TimeoutRootCauseAnalyzer:
\n """\u8d85\u65f6\u6839\u56e0\u5206\u6790\u7cfb\u7edf"""<\/p>\n
def __init__(self, config: Dict = None):
\n self.config = {
\n 'window_size': 1000, # \u5206\u6790\u7a97\u53e3\u5927\u5c0f
\n 'percentile_threshold': 95, # \u767e\u5206\u4f4d\u9608\u503c
\n 'anomaly_threshold': 3.0, # \u5f02\u5e38\u9608\u503c（\u6807\u51c6\u5dee）
\n 'correlation_threshold': 0.7, # \u76f8\u5173\u6027\u9608\u503c
\n 'min_samples': 50, # \u6700\u5c0f\u6837\u672c\u6570
\n ** (config or {})
\n }<\/p>\n
# \u6570\u636e\u5b58\u50a8
\n self.timeout_data = deque(maxlen=self.config['window_size'])
\n self.normal_data = deque(maxlen=self.config['window_size'])
\n self.metrics_history = defaultdict(lambda: deque(maxlen=100))<\/p>\n
# \u7edf\u8ba1\u4fe1\u606f
\n self.statistics = {
\n 'total_timeouts': 0,
\n 'timeout_rate': 0.0,
\n 'avg_timeout_duration': 0.0,
\n 'timeout_patterns': defaultdict(int)
\n }<\/p>\n
# \u6839\u56e0\u5206\u6790\u6a21\u578b
\n self.cause_models = self.initialize_cause_models()<\/p>\n
def initialize_cause_models(self) -> Dict:
\n """\u521d\u59cb\u5316\u6839\u56e0\u5206\u6790\u6a21\u578b"""
\n return {
\n 'network': {
\n 'indicators': ['latency', 'packet_loss', 'throughput'],
\n 'thresholds': {
\n 'latency': 500, # ms
\n 'packet_loss': 0.1, # 10%
\n 'throughput': 1024 # 1KB\/s
\n },
\n 'weight': 0.3
\n },
\n 'server': {
\n 'indicators': ['cpu_usage', 'memory_usage', 'disk_io'],
\n 'thresholds': {
\n 'cpu_usage': 0.8, # 80%
\n 'memory_usage': 0.9, # 90%
\n 'disk_io': 1000 # 1000 IOPS
\n },
\n 'weight': 0.4
\n },
\n 'application': {
\n 'indicators': ['response_time', 'error_rate', 'queue_length'],
\n 'thresholds': {
\n 'response_time': 5.0, # 5\u79d2
\n 'error_rate': 0.05, # 5%
\n 'queue_length': 100
\n },
\n 'weight': 0.2
\n },
\n 'client': {
\n 'indicators': ['request_size', 'concurrent_requests', 'geolocation'],
\n 'thresholds': {
\n 'request_size': 10 * 1024 * 1024, # 10MB
\n 'concurrent_requests': 10,
\n 'geolocation_distance': 1000 # 1000km
\n },
\n 'weight': 0.1
\n }
\n }<\/p>\n
def record_timeout(self, timeout_event: Dict):
\n """\u8bb0\u5f55\u8d85\u65f6\u4e8b\u4ef6"""
\n self.timeout_data.append({
\n 'timestamp': datetime.utcnow(),
\n 'data': timeout_event
\n })<\/p>\n
self.statistics['total_timeouts'] += 1<\/p>\n
# \u66f4\u65b0\u7edf\u8ba1
\n self.update_statistics()<\/p>\n
# \u5206\u6790\u6839\u56e0
\n root_cause = self.analyze_root_cause(timeout_event)<\/p>\n
# \u8bb0\u5f55\u6a21\u5f0f
\n if root_cause:
\n self.statistics['timeout_patterns'][root_cause['primary_cause']] += 1<\/p>\n
return root_cause<\/p>\n
def record_normal_request(self, request_data: Dict):
\n """\u8bb0\u5f55\u6b63\u5e38\u8bf7\u6c42"""
\n self.normal_data.append({
\n 'timestamp': datetime.utcnow(),
\n 'data': request_data
\n })<\/p>\n
# \u66f4\u65b0\u6307\u6807\u5386\u53f2
\n for metric, value in request_data.get('metrics', {}).items():
\n self.metrics_history[metric].append(value)<\/p>\n
def analyze_root_cause(self, timeout_event: Dict) -> Optional[Dict]:
\n """\u5206\u6790\u8d85\u65f6\u6839\u56e0"""<\/p>\n
# \u6536\u96c6\u6307\u6807
\n indicators = self.collect_indicators(timeout_event)<\/p>\n
# \u8ba1\u7b97\u5404\u539f\u56e0\u7684\u53ef\u80fd\u6027
\n cause_scores = {}
\n for cause_name, cause_model in self.cause_models.items():
\n score = self.calculate_cause_score(cause_model, indicators)
\n cause_scores[cause_name] = score<\/p>\n
# \u627e\u51fa\u4e3b\u8981\u539f\u56e0
\n primary_cause = max(cause_scores.items(), key=lambda x: x[1])<\/p>\n
if primary_cause[1] > 0.5: # \u9608\u503c
\n return {
\n 'primary_cause': primary_cause[0],
\n 'confidence': primary_cause[1],
\n 'cause_scores': cause_scores,
\n 'indicators': indicators,
\n 'recommendations': self.generate_recommendations(primary_cause[0], indicators)
\n }<\/p>\n
return None<\/p>\n
def collect_indicators(self, timeout_event: Dict) -> Dict:
\n """\u6536\u96c6\u6307\u6807"""
\n indicators = {}<\/p>\n
# \u7f51\u7edc\u6307\u6807
\n indicators['latency'] = timeout_event.get('latency', 0)
\n indicators['packet_loss'] = timeout_event.get('packet_loss', 0)
\n indicators['throughput'] = timeout_event.get('throughput', 0)<\/p>\n
# \u670d\u52a1\u5668\u6307\u6807
\n indicators['cpu_usage'] = timeout_event.get('cpu_usage', 0)
\n indicators['memory_usage'] = timeout_event.get('memory_usage', 0)
\n indicators['disk_io'] = timeout_event.get('disk_io', 0)<\/p>\n
# \u5e94\u7528\u6307\u6807
\n indicators['response_time'] = timeout_event.get('response_time', 0)
\n indicators['error_rate'] = timeout_event.get('error_rate', 0)
\n indicators['queue_length'] = timeout_event.get('queue_length', 0)<\/p>\n
# \u5ba2\u6237\u7aef\u6307\u6807
\n indicators['request_size'] = timeout_event.get('request_size', 0)
\n indicators['concurrent_requests'] = timeout_event.get('concurrent_requests', 0)
\n indicators['geolocation_distance'] = timeout_event.get('geolocation_distance', 0)<\/p>\n
return indicators<\/p>\n
def calculate_cause_score(self, cause_model: Dict, indicators: Dict) -> float:
\n """\u8ba1\u7b97\u539f\u56e0\u5206\u6570"""
\n score = 0.0
\n total_weight = 0.0<\/p>\n
for indicator in cause_model['indicators']:
\n if indicator in indicators:
\n value = indicators[indicator]
\n threshold = cause_model['thresholds'].get(indicator, 0)<\/p>\n
# \u8ba1\u7b97\u6307\u6807\u5206\u6570
\n indicator_score = self.calculate_indicator_score(value, threshold)<\/p>\n
# \u52a0\u6743
\n score += indicator_score
\n total_weight += 1.0<\/p>\n
if total_weight > 0:
\n score = score \/ total_weight * cause_model['weight']<\/p>\n
return score<\/p>\n
def calculate_indicator_score(self, value: float, threshold: float) -> float:
\n """\u8ba1\u7b97\u6307\u6807\u5206\u6570"""
\n if threshold == 0:
\n return 0.0<\/p>\n
# \u5f52\u4e00\u5316\u5e76\u8ba1\u7b97\u8d85\u51fa\u7a0b\u5ea6
\n normalized = min(value \/ threshold, 2.0) # \u9650\u5236\u57282\u500d\u4ee5\u5185
\n score = max(0, normalized – 1) # \u8d85\u8fc7\u9608\u503c\u90e8\u5206<\/p>\n
return score<\/p>\n
def generate_recommendations(self, cause: str, indicators: Dict) -> List[str]:
\n """\u751f\u6210\u63a8\u8350\u89e3\u51b3\u65b9\u6848"""
\n recommendations = []<\/p>\n
if cause == 'network':
\n if indicators.get('latency', 0) > 500:
\n recommendations.append('\u4f18\u5316\u7f51\u7edc\u8def\u7531\u6216\u4f7f\u7528CDN')
\n if indicators.get('packet_loss', 0) > 0.1:
\n recommendations.append('\u68c0\u67e5\u7f51\u7edc\u7a33\u5b9a\u6027\u6216\u589e\u52a0\u91cd\u8bd5\u673a\u5236')
\n if indicators.get('throughput', 0) < 1024:
\n recommendations.append('\u5347\u7ea7\u7f51\u7edc\u5e26\u5bbd\u6216\u538b\u7f29\u4f20\u8f93\u6570\u636e')<\/p>\n
elif cause == 'server':
\n if indicators.get('cpu_usage', 0) > 0.8:
\n recommendations.append('\u589e\u52a0CPU\u8d44\u6e90\u6216\u4f18\u5316\u4ee3\u7801')
\n if indicators.get('memory_usage', 0) > 0.9:
\n recommendations.append('\u589e\u52a0\u5185\u5b58\u6216\u4f18\u5316\u5185\u5b58\u4f7f\u7528')
\n if indicators.get('disk_io', 0) > 1000:
\n recommendations.append('\u4f18\u5316\u78c1\u76d8I\/O\u6216\u4f7f\u7528SSD')<\/p>\n
elif cause == 'application':
\n if indicators.get('response_time', 0) > 5.0:
\n recommendations.append('\u4f18\u5316\u6570\u636e\u5e93\u67e5\u8be2\u6216\u7f13\u5b58\u7b56\u7565')
\n if indicators.get('error_rate', 0) > 0.05:
\n recommendations.append('\u4fee\u590d\u5e94\u7528\u9519\u8bef\u6216\u589e\u52a0\u9519\u8bef\u5904\u7406')
\n if indicators.get('queue_length', 0) > 100:
\n recommendations.append('\u589e\u52a0\u5904\u7406\u80fd\u529b\u6216\u5b9e\u73b0\u8d1f\u8f7d\u5747\u8861')<\/p>\n
elif cause == 'client':
\n if indicators.get('request_size', 0) > 10 * 1024 * 1024:
\n recommendations.append('\u538b\u7f29\u8bf7\u6c42\u6570\u636e\u6216\u5206\u5757\u4e0a\u4f20')
\n if indicators.get('concurrent_requests', 0) > 10:
\n recommendations.append('\u9650\u5236\u5ba2\u6237\u7aef\u5e76\u53d1\u8bf7\u6c42\u6570')<\/p>\n
# \u901a\u7528\u63a8\u8350
\n recommendations.extend([
\n '\u589e\u52a0\u8d85\u65f6\u65f6\u95f4\u914d\u7f6e',
\n '\u5b9e\u73b0\u66f4\u597d\u7684\u91cd\u8bd5\u673a\u5236',
\n '\u76d1\u63a7\u7cfb\u7edf\u6027\u80fd\u6307\u6807'
\n ])<\/p>\n
return recommendations<\/p>\n
def detect_anomalies(self) -> List[Dict]:
\n """\u68c0\u6d4b\u5f02\u5e38\u6a21\u5f0f"""
\n anomalies = []<\/p>\n
if len(self.timeout_data) < self.config['min_samples']:
\n return anomalies<\/p>\n
# \u5206\u6790\u8d85\u65f6\u7387
\n timeout_rate = self.calculate_timeout_rate()
\n if timeout_rate > self.calculate_threshold('timeout_rate'):
\n anomalies.append({
\n 'type': 'high_timeout_rate',
\n 'value': timeout_rate,
\n 'threshold': self.calculate_threshold('timeout_rate'),
\n 'severity': 'high'
\n })<\/p>\n
# \u5206\u6790\u8d85\u65f6\u6301\u7eed\u65f6\u95f4
\n durations = [event['data'].get('duration', 0) for event in self.timeout_data]
\n if durations:
\n avg_duration = statistics.mean(durations)
\n p95_duration = np.percentile(durations, 95)<\/p>\n
if p95_duration > self.calculate_threshold('timeout_duration'):
\n anomalies.append({
\n 'type': 'long_timeout_duration',
\n 'p95_duration': p95_duration,
\n 'threshold': self.calculate_threshold('timeout_duration'),
\n 'severity': 'medium'
\n })<\/p>\n
# \u5206\u6790\u65f6\u95f4\u76f8\u5173\u6027
\n time_pattern = self.analyze_time_pattern()
\n if time_pattern['has_pattern']:
\n anomalies.append({
\n 'type': 'time_pattern_detected',
\n 'pattern': time_pattern['pattern'],
\n 'confidence': time_pattern['confidence'],
\n 'severity': 'low'
\n })<\/p>\n
return anomalies<\/p>\n
def calculate_timeout_rate(self) -> float:
\n """\u8ba1\u7b97\u8d85\u65f6\u7387"""
\n window_seconds = 300 # 5\u5206\u949f\u7a97\u53e3
\n cutoff = datetime.utcnow() – timedelta(seconds=window_seconds)<\/p>\n
timeout_count = sum(1 for event in self.timeout_data
\n if event['timestamp'] > cutoff)<\/p>\n
total_count = timeout_count + len([event for event in self.normal_data
\n if event['timestamp'] > cutoff])<\/p>\n
return timeout_count \/ total_count if total_count > 0 else 0.0<\/p>\n
def calculate_threshold(self, metric: str) -> float:
\n """\u8ba1\u7b97\u5f02\u5e38\u9608\u503c"""
\n # \u57fa\u4e8e\u5386\u53f2\u6570\u636e\u8ba1\u7b97\u52a8\u6001\u9608\u503c
\n if metric == 'timeout_rate':
\n historical_values = [self.statistics.get('timeout_rate', 0)]
\n return np.mean(historical_values) + 2 * np.std(historical_values)<\/p>\n
elif metric == 'timeout_duration':
\n durations = [event['data'].get('duration', 0) for event in self.timeout_data]
\n if durations:
\n return np.percentile(durations, 95) * 1.5
\n return 30.0 # \u9ed8\u8ba430\u79d2<\/p>\n
return 0.0<\/p>\n
def analyze_time_pattern(self) -> Dict:
\n """\u5206\u6790\u65f6\u95f4\u6a21\u5f0f"""
\n if len(self.timeout_data) < 10:
\n return {'has_pattern': False}<\/p>\n
# \u63d0\u53d6\u8d85\u65f6\u65f6\u95f4\u70b9
\n time_points = [event['timestamp'].hour for event in self.timeout_data]<\/p>\n
# \u5206\u6790\u65f6\u95f4\u5206\u5e03
\n hour_counts = defaultdict(int)
\n for hour in time_points:
\n hour_counts[hour] += 1<\/p>\n
# \u68c0\u67e5\u662f\u5426\u6709\u660e\u663e\u7684\u65f6\u95f4\u6a21\u5f0f
\n max_hour = max(hour_counts.items(), key=lambda x: x[1])
\n total = len(time_points)<\/p>\n
if max_hour[1] \/ total > 0.3: # 30%\u7684\u8d85\u65f6\u53d1\u751f\u5728\u540c\u4e00\u5c0f\u65f6
\n return {
\n 'has_pattern': True,
\n 'pattern': f'Peak at hour {max_hour[0]}',
\n 'confidence': max_hour[1] \/ total
\n }<\/p>\n
return {'has_pattern': False}<\/p>\n
def update_statistics(self):
\n """\u66f4\u65b0\u7edf\u8ba1\u4fe1\u606f"""
\n window_seconds = 3600 # 1\u5c0f\u65f6\u7a97\u53e3
\n cutoff = datetime.utcnow() – timedelta(seconds=window_seconds)<\/p>\n
# \u8ba1\u7b97\u8d85\u65f6\u7387
\n timeout_count = sum(1 for event in self.timeout_data
\n if event['timestamp'] > cutoff)
\n total_count = timeout_count + len([event for event in self.normal_data
\n if event['timestamp'] > cutoff])<\/p>\n
self.statistics['timeout_rate'] = timeout_count \/ total_count if total_count > 0 else 0.0<\/p>\n
# \u8ba1\u7b97\u5e73\u5747\u8d85\u65f6\u6301\u7eed\u65f6\u95f4
\n recent_timeouts = [event for event in self.timeout_data
\n if event['timestamp'] > cutoff]<\/p>\n
if recent_timeouts:
\n durations = [event['data'].get('duration', 0) for event in recent_timeouts]
\n self.statistics['avg_timeout_duration'] = statistics.mean(durations)<\/p>\n
def generate_report(self, period: str = '24h') -> Dict:
\n """\u751f\u6210\u5206\u6790\u62a5\u544a"""
\n if period == '24h':
\n cutoff = datetime.utcnow() – timedelta(hours=24)
\n elif period == '7d':
\n cutoff = datetime.utcnow() – timedelta(days=7)
\n else:
\n cutoff = datetime.utcnow() – timedelta(hours=24)<\/p>\n
# \u7b5b\u9009\u671f\u95f4\u6570\u636e
\n period_timeouts = [event for event in self.timeout_data
\n if event['timestamp'] > cutoff]
\n period_normals = [event for event in self.normal_data
\n if event['timestamp'] > cutoff]<\/p>\n
# \u57fa\u7840\u7edf\u8ba1
\n total_requests = len(period_timeouts) + len(period_normals)
\n timeout_rate = len(period_timeouts) \/ total_requests if total_requests > 0 else 0<\/p>\n
# \u6839\u56e0\u5206\u5e03
\n cause_distribution = defaultdict(int)
\n for event in period_timeouts:
\n root_cause = self.analyze_root_cause(event['data'])
\n if root_cause:
\n cause_distribution[root_cause['primary_cause']] += 1<\/p>\n
# \u65f6\u95f4\u5206\u5e03
\n hourly_distribution = defaultdict(int)
\n for event in period_timeouts:
\n hour = event['timestamp'].hour
\n hourly_distribution[f'{hour:02d}:00'] += 1<\/p>\n
report = {
\n 'period': period,
\n 'time_range': {
\n 'start': cutoff.isoformat(),
\n 'end': datetime.utcnow().isoformat()
\n },
\n 'summary': {
\n 'total_requests': total_requests,
\n 'timeout_count': len(period_timeouts),
\n 'timeout_rate': timeout_rate,
\n 'avg_timeout_duration': self.statistics['avg_timeout_duration']
\n },
\n 'cause_analysis': {
\n 'distribution': dict(cause_distribution),
\n 'top_causes': sorted(cause_distribution.items(),
\n key=lambda x: x[1], reverse=True)[:5]
\n },
\n 'time_distribution': dict(sorted(hourly_distribution.items())),
\n 'anomalies': self.detect_anomalies(),
\n 'recommendations': self.generate_overall_recommendations()
\n }<\/p>\n
return report<\/p>\n
def generate_overall_recommendations(self) -> List[str]:
\n """\u751f\u6210\u6574\u4f53\u63a8\u8350"""
\n recommendations = []<\/p>\n
# \u57fa\u4e8e\u6839\u56e0\u5206\u6790
\n for cause, count in self.statistics['timeout_patterns'].items():
\n if count > 10: # \u9891\u7e41\u51fa\u73b0\u7684\u539f\u56e0
\n if cause == 'network':
\n recommendations.append('\u8003\u8651\u4f18\u5316\u7f51\u7edc\u57fa\u7840\u8bbe\u65bd\u6216\u4f7f\u7528CDN')
\n elif cause == 'server':
\n recommendations.append('\u5efa\u8bae\u589e\u52a0\u670d\u52a1\u5668\u8d44\u6e90\u6216\u4f18\u5316\u914d\u7f6e')
\n elif cause == 'application':
\n recommendations.append('\u9700\u8981\u6027\u80fd\u4f18\u5316\u548c\u4ee3\u7801\u5ba1\u67e5')
\n elif cause == 'client':
\n recommendations.append('\u5efa\u8bae\u6539\u5584\u5ba2\u6237\u7aef\u5b9e\u73b0\u548c\u6dfb\u52a0\u9650\u5236')<\/p>\n
# \u57fa\u4e8e\u8d85\u65f6\u7387
\n if self.statistics['timeout_rate'] > 0.1: # \u8d85\u65f6\u7387\u8d85\u8fc710%
\n recommendations.append('\u6574\u4f53\u8d85\u65f6\u7387\u8fc7\u9ad8，\u5efa\u8bae\u5168\u9762\u5ba1\u67e5\u7cfb\u7edf\u67b6\u6784')<\/p>\n
# \u57fa\u4e8e\u6301\u7eed\u65f6\u95f4
\n if self.statistics['avg_timeout_duration'] > 30: # \u5e73\u5747\u8d85\u65f6\u8d85\u8fc730\u79d2
\n recommendations.append('\u8d85\u65f6\u6301\u7eed\u65f6\u95f4\u8fc7\u957f，\u5efa\u8bae\u589e\u52a0\u8d85\u65f6\u914d\u7f6e\u6216\u4f18\u5316\u5904\u7406\u903b\u8f91')<\/p>\n
return list(set(recommendations))[:5] # \u53bb\u91cd\u5e76\u9650\u5236\u6570\u91cf<\/p>\n
javascript<\/p>\n
\/\/ React\u7ec4\u4ef6：\u5b9e\u65f6\u8d85\u65f6\u76d1\u63a7\u4eea\u8868\u677f
\nimport React, { useState, useEffect, useRef } from 'react';
\nimport {
\n LineChart, Line, BarChart, Bar, PieChart, Pie, Cell,
\n XAxis, YAxis, CartesianGrid, Tooltip, Legend, ResponsiveContainer,
\n AreaChart, Area, RadarChart, Radar, PolarGrid, PolarAngleAxis, PolarRadiusAxis
\n} from 'recharts';
\nimport { AlertTriangle, Clock, Activity, Wifi, Server, Cpu, AlertCircle } from 'lucide-react';<\/p>\n
function TimeoutMonitoringDashboard() {
\n const [timeRange, setTimeRange] = useState('1h');
\n const [stats, setStats] = useState(null);
\n const [realtimeEvents, setRealtimeEvents] = useState([]);
\n const [anomalies, setAnomalies] = useState([]);
\n const [causeDistribution, setCauseDistribution] = useState([]);
\n const [networkMetrics, setNetworkMetrics] = useState({});<\/p>\n
const wsRef = useRef(null);<\/p>\n
\/\/ \u989c\u8272\u914d\u7f6e
\n const COLORS = ['#0088FE', '#00C49F', '#FFBB28', '#FF8042', '#8884D8'];<\/p>\n
\/\/ \u83b7\u53d6\u7edf\u8ba1\u6570\u636e
\n useEffect(() => {
\n const fetchStats = async () => {
\n try {
\n const response = await fetch(`\/api\/monitor\/timeout-stats?range=${timeRange}`);
\n const data = await response.json();
\n setStats(data);<\/p>\n
\/\/ \u5904\u7406\u6839\u56e0\u5206\u5e03\u6570\u636e
\n if (data.cause_analysis?.distribution) {
\n const distribution = Object.entries(data.cause_analysis.distribution)
\n .map(([name, value]) => ({ name, value }));
\n setCauseDistribution(distribution);
\n }
\n } catch (error) {
\n console.error('Failed to fetch stats:', error);
\n }
\n };<\/p>\n
fetchStats();
\n const interval = setInterval(fetchStats, 30000); \/\/ \u6bcf30\u79d2\u66f4\u65b0<\/p>\n
return () => clearInterval(interval);
\n }, [timeRange]);<\/p>\n
\/\/ WebSocket\u8fde\u63a5\u63a5\u6536\u5b9e\u65f6\u4e8b\u4ef6
\n useEffect(() => {
\n const connectWebSocket = () => {
\n wsRef.current = new WebSocket('wss:\/\/api.example.com\/monitor\/timeout-events');<\/p>\n
wsRef.current.onmessage = (event) => {
\n const eventData = JSON.parse(event.data);<\/p>\n
\/\/ \u6dfb\u52a0\u4e8b\u4ef6\u5230\u5b9e\u65f6\u5217\u8868
\n setRealtimeEvents(prev => [
\n { …eventData, id: Date.now() },
\n …prev.slice(0, 49) \/\/ \u4fdd\u7559\u6700\u8fd150\u4e2a
\n ]);<\/p>\n
\/\/ \u68c0\u67e5\u662f\u5426\u662f\u5f02\u5e38\u4e8b\u4ef6
\n if (eventData.severity === 'high') {
\n setAnomalies(prev => [
\n {
\n …eventData,
\n id: Date.now(),
\n acknowledged: false
\n },
\n …prev
\n ]);
\n }<\/p>\n
\/\/ \u66f4\u65b0\u7f51\u7edc\u6307\u6807
\n if (eventData.metrics) {
\n setNetworkMetrics(prev => ({
\n …prev,
\n …eventData.metrics,
\n lastUpdated: Date.now()
\n }));
\n }
\n };<\/p>\n
wsRef.current.onclose = () => {
\n console.log('WebSocket closed, reconnecting…');
\n setTimeout(connectWebSocket, 5000);
\n };<\/p>\n
wsRef.current.onerror = (error) => {
\n console.error('WebSocket error:', error);
\n };
\n };<\/p>\n
connectWebSocket();<\/p>\n
return () => {
\n if (wsRef.current) {
\n wsRef.current.close();
\n }
\n };
\n }, []);<\/p>\n
\/\/ \u6a21\u62df\u7f51\u7edc\u6307\u6807\u66f4\u65b0
\n useEffect(() => {
\n const updateNetworkMetrics = () => {
\n setNetworkMetrics(prev => ({
\n latency: Math.random() * 500,
\n throughput: 1000 + Math.random() * 5000,
\n packetLoss: Math.random() * 0.05,
\n reliability: 0.95 + Math.random() * 0.05,
\n lastUpdated: Date.now()
\n }));
\n };<\/p>\n
const interval = setInterval(updateNetworkMetrics, 10000);
\n return () => clearInterval(interval);
\n }, []);<\/p>\n
if (!stats) {
\n return (
\n <div className="loading-container">
\n <div className="spinner"><\/div>
\n <p>\u52a0\u8f7d\u76d1\u63a7\u6570\u636e…<\/p>
\n <\/div>
\n );
\n }<\/p>\n
return (
\n <div className="dashboard timeout-dashboard">
\n {\/* \u4eea\u8868\u677f\u5934\u90e8 *\/}
\n <div className="dashboard-header">
\n <div className="header-left">
\n <Clock size={32} className="header-icon" \/>
\n <h1>\u8bf7\u6c42\u8d85\u65f6\u76d1\u63a7<\/h1>
\n <span className="time-range-label">
\n \u65f6\u95f4\u8303\u56f4: {timeRange === '1h' ? '1\u5c0f\u65f6' :
\n timeRange === '24h' ? '24\u5c0f\u65f6' :
\n timeRange === '7d' ? '7\u5929' : '30\u5929'}
\n <\/span>
\n <\/div><\/p>\n
<div className="header-right">
\n <div className="time-range-selector">
\n {['1h', '24h', '7d', '30d'].map(range => (
\n <button
\n key={range}
\n className={`time-range-btn ${timeRange === range ? 'active' : ''}`}
\n onClick={() => setTimeRange(range)}
\n >
\n {range}
\n <\/button>
\n ))}
\n <\/div><\/p>\n
<button className="export-btn" onClick={() => exportReport()}>
\n \u5bfc\u51fa\u62a5\u544a
\n <\/button>
\n <\/div>
\n <\/div><\/p>\n
{\/* \u5173\u952e\u6307\u6807\u5361\u7247 *\/}
\n <div className="key-metrics-cards">
\n <div className="metric-card critical">
\n <div className="metric-icon">
\n <AlertTriangle size={24} \/>
\n <\/div>
\n <div className="metric-content">
\n <h3>\u8d85\u65f6\u603b\u6570<\/h3>
\n <p className="metric-value">{stats.summary.timeout_count}<\/p>
\n <p className="metric-trend">
\n \u7387: {(stats.summary.timeout_rate * 100).toFixed(2)}%
\n <\/p>
\n <\/div>
\n <\/div><\/p>\n
<div className="metric-card warning">
\n <div className="metric-icon">
\n <Clock size={24} \/>
\n <\/div>
\n <div className="metric-content">
\n <h3>\u5e73\u5747\u8d85\u65f6<\/h3>
\n <p className="metric-value">
\n {stats.summary.avg_timeout_duration?.toFixed(1) || '0.0'}s
\n <\/p>
\n <p className="metric-trend">
\n \u9608\u503c: 30.0s
\n <\/p>
\n <\/div>
\n <\/div><\/p>\n
<div className="metric-card info">
\n <div className="metric-icon">
\n <Activity size={24} \/>
\n <\/div>
\n <div className="metric-content">
\n <h3>\u603b\u8bf7\u6c42\u6570<\/h3>
\n <p className="metric-value">
\n {stats.summary.total_requests?.toLocaleString() || '0'}
\n <\/p>
\n <p className="metric-trend">
\n {stats.summary.total_requests > 0 ? '\u6b63\u5e38' : '\u65e0\u6570\u636e'}
\n <\/p>
\n <\/div>
\n <\/div><\/p>\n
<div className="metric-card success">
\n <div className="metric-icon">
\n <Server size={24} \/>
\n <\/div>
\n <div className="metric-content">
\n <h3>\u6b63\u5e38\u7387<\/h3>
\n <p className="metric-value">
\n {((1 – stats.summary.timeout_rate) * 100).toFixed(1)}%
\n <\/p>
\n <p className="metric-trend">
\n \u76ee\u6807: 99.9%
\n <\/p>
\n <\/div>
\n <\/div>
\n <\/div><\/p>\n
{\/* \u7f51\u7edc\u6307\u6807\u5361\u7247 *\/}
\n <div className="network-metrics">
\n <h3>\u7f51\u7edc\u8d28\u91cf\u6307\u6807<\/h3>
\n <div className="network-cards">
\n <div className="network-card">
\n <Wifi size={20} \/>
\n <span className="network-label">\u5ef6\u8fdf<\/span>
\n <span className={`network-value ${networkMetrics.latency > 200 ? 'warning' : ''}`}>
\n {networkMetrics.latency?.toFixed(0) || '0'}ms
\n <\/span>
\n <\/div><\/p>\n
<div className="network-card">
\n <Activity size={20} \/>
\n <span className="network-label">\u541e\u5410\u91cf<\/span>
\n <span className="network-value">
\n {(networkMetrics.throughput \/ 1000).toFixed(1)}kbps
\n <\/span>
\n <\/div><\/p>\n
<div className="network-card">
\n <AlertCircle size={20} \/>
\n <span className="network-label">\u4e22\u5305\u7387<\/span>
\n <span className={`network-value ${networkMetrics.packetLoss > 0.02 ? 'critical' : ''}`}>
\n {(networkMetrics.packetLoss * 100).toFixed(2)}%
\n <\/span>
\n <\/div><\/p>\n
<div className="network-card">
\n <Cpu size={20} \/>
\n <span className="network-label">\u53ef\u9760\u6027<\/span>
\n <span className="network-value">
\n {(networkMetrics.reliability * 100).toFixed(1)}%
\n <\/span>
\n <\/div>
\n <\/div>
\n <\/div><\/p>\n
{\/* \u56fe\u8868\u533a\u57df *\/}
\n <div className="charts-section">
\n <div className="chart-row">
\n <div className="chart-container">
\n <h3>\u8d85\u65f6\u8d8b\u52bf<\/h3>
\n <ResponsiveContainer width="100%" height={300}>
\n <LineChart data={Object.entries(stats.time_distribution || {}).map(([hour, count]) => ({ hour, count }))}>
\n <CartesianGrid strokeDasharray="3 3" \/>
\n <XAxis dataKey="hour" \/>
\n <YAxis \/>
\n <Tooltip \/>
\n <Legend \/>
\n <Line
\n type="monotone"
\n dataKey="count"
\n stroke="#ff6b6b"
\n strokeWidth={2}
\n dot={{ r: 4 }}
\n activeDot={{ r: 6 }}
\n name="\u8d85\u65f6\u6b21\u6570"
\n \/>
\n <\/LineChart>
\n <\/ResponsiveContainer>
\n <\/div><\/p>\n
<div className="chart-container">
\n <h3>\u6839\u56e0\u5206\u5e03<\/h3>
\n <ResponsiveContainer width="100%" height={300}>
\n <PieChart>
\n <Pie
\n data={causeDistribution}
\n cx="50%"
\n cy="50%"
\n labelLine={false}
\n label={({ name, percent }) => `${name}: ${(percent * 100).toFixed(0)}%`}
\n outerRadius={80}
\n fill="#8884d8"
\n dataKey="value"
\n >
\n {causeDistribution.map((entry, index) => (
\n <Cell key={`cell-${index}`} fill={COLORS[index % COLORS.length]} \/>
\n ))}
\n <\/Pie>
\n <Tooltip formatter={(value) => [`${value}\u6b21`, '\u6570\u91cf']} \/>
\n <\/PieChart>
\n <\/ResponsiveContainer>
\n <\/div>
\n <\/div><\/p>\n
<div className="chart-row">
\n <div className="chart-container">
\n <h3>\u8d85\u65f6\u7387\u53d8\u5316<\/h3>
\n <ResponsiveContainer width="100%" height={300}>
\n <AreaChart data={generateRateData()}>
\n <CartesianGrid strokeDasharray="3 3" \/>
\n <XAxis dataKey="time" \/>
\n <YAxis label={{ value: '\u8d85\u65f6\u7387 (%)', angle: -90, position: 'insideLeft' }} \/>
\n <Tooltip formatter={(value) => [`${value}%`, '\u8d85\u65f6\u7387']} \/>
\n <Area
\n type="monotone"
\n dataKey="rate"
\n stroke="#8884d8"
\n fill="#8884d8"
\n fillOpacity={0.3}
\n name="\u8d85\u65f6\u7387"
\n \/>
\n <Line
\n type="monotone"
\n dataKey="threshold"
\n stroke="#ff6b6b"
\n strokeDasharray="5 5"
\n name="\u8b66\u544a\u9608\u503c"
\n dot={false}
\n \/>
\n <\/AreaChart>
\n <\/ResponsiveContainer>
\n <\/div><\/p>\n
<div className="chart-container">
\n <h3>\u6027\u80fd\u6307\u6807\u96f7\u8fbe\u56fe<\/h3>
\n <ResponsiveContainer width="100%" height={300}>
\n <RadarChart data={generateRadarData()}>
\n <PolarGrid \/>
\n <PolarAngleAxis dataKey="subject" \/>
\n <PolarRadiusAxis angle={30} domain={[0, 100]} \/>
\n <Radar
\n name="\u5f53\u524d"
\n dataKey="current"
\n stroke="#8884d8"
\n fill="#8884d8"
\n fillOpacity={0.3}
\n \/>
\n <Radar
\n name="\u76ee\u6807"
\n dataKey="target"
\n stroke="#82ca9d"
\n fill="#82ca9d"
\n fillOpacity={0.3}
\n \/>
\n <Legend \/>
\n <Tooltip \/>
\n <\/RadarChart>
\n <\/ResponsiveContainer>
\n <\/div>
\n <\/div>
\n <\/div><\/p>\n
{\/* \u5b9e\u65f6\u4e8b\u4ef6\u6d41 *\/}
\n <div className="realtime-events-section">
\n <h3>\u5b9e\u65f6\u8d85\u65f6\u4e8b\u4ef6<\/h3>
\n <div className="events-table-container">
\n <table className="events-table">
\n <thead>
\n <tr>
\n <th>\u65f6\u95f4<\/th>
\n <th>\u7aef\u70b9<\/th>
\n <th>\u6301\u7eed\u65f6\u95f4<\/th>
\n <th>\u6839\u56e0<\/th>
\n <th>\u5ba2\u6237\u7aefIP<\/th>
\n <th>\u4e25\u91cd\u7a0b\u5ea6<\/th>
\n <th>\u64cd\u4f5c<\/th>
\n <\/tr>
\n <\/thead>
\n <tbody>
\n {realtimeEvents.map(event => (
\n <tr
\n key={event.id}
\n className={`event-row severity-${event.severity || 'medium'}`}
\n >
\n <td>
\n {new Date(event.timestamp || Date.now()).toLocaleTimeString()}
\n <\/td>
\n <td className="endpoint-cell">
\n <code title={event.endpoint}>
\n {event.endpoint?.length > 30 ?
\n event.endpoint.substring(0, 30) + '…' :
\n event.endpoint}
\n <\/code>
\n <\/td>
\n <td>
\n <span className="duration-badge">
\n {event.duration ? `${event.duration.toFixed(2)}s` : 'N\/A'}
\n <\/span>
\n <\/td>
\n <td>
\n <span className={`cause-badge cause-${event.root_cause?.toLowerCase() || 'unknown'}`}>
\n {event.root_cause || '\u672a\u77e5'}
\n <\/span>
\n <\/td>
\n <td>
\n <code>{event.client_ip || 'N\/A'}<\/code>
\n <\/td>
\n <td>
\n <span className={`severity-badge severity-${event.severity || 'medium'}`}>
\n {event.severity === 'high' ? '\u9ad8' :
\n event.severity === 'medium' ? '\u4e2d' : '\u4f4e'}
\n <\/span>
\n <\/td>
\n <td>
\n <button
\n className="action-btn view-details"
\n onClick={() => viewEventDetails(event)}
\n >
\n \u8be6\u60c5
\n <\/button>
\n <button
\n className="action-btn acknowledge"
\n onClick={() => acknowledgeEvent(event.id)}
\n >
\n \u786e\u8ba4
\n <\/button>
\n <\/td>
\n <\/tr>
\n ))}
\n <\/tbody>
\n <\/table>
\n <\/div>
\n <\/div><\/p>\n
{\/* \u5f02\u5e38\u8b66\u62a5 *\/}
\n {anomalies.length > 0 && (
\n <div className="anomalies-section">
\n <h3>
\n <AlertTriangle size={20} \/>
\n \u5f02\u5e38\u8b66\u62a5 ({anomalies.length})
\n <\/h3>
\n <div className="anomalies-list">
\n {anomalies.filter(a => !a.acknowledged).slice(0, 5).map(anomaly => (
\n <div key={anomaly.id} className="anomaly-card">
\n <div className="anomaly-header">
\n <span className="anomaly-type">{anomaly.type}<\/span>
\n <span className="anomaly-time">
\n {new Date(anomaly.timestamp).toLocaleTimeString()}
\n <\/span>
\n <\/div>
\n <div className="anomaly-content">
\n <p>{anomaly.message || '\u68c0\u6d4b\u5230\u5f02\u5e38\u6a21\u5f0f'}<\/p>
\n {anomaly.details && (
\n <div className="anomaly-details">
\n <pre>{JSON.stringify(anomaly.details, null, 2)}<\/pre>
\n <\/div>
\n )}
\n <\/div>
\n <div className="anomaly-actions">
\n <button
\n className="btn btn-primary"
\n onClick={() => investigateAnomaly(anomaly)}
\n >
\n \u8c03\u67e5
\n <\/button>
\n <button
\n className="btn btn-secondary"
\n onClick={() => acknowledgeAnomaly(anomaly.id)}
\n >
\n \u786e\u8ba4
\n <\/button>
\n <button
\n className="btn btn-tertiary"
\n onClick={() => muteAnomaly(anomaly.id)}
\n >
\n \u9759\u97f3
\n <\/button>
\n <\/div>
\n <\/div>
\n ))}
\n <\/div>
\n <\/div>
\n )}<\/p>\n
{\/* \u5efa\u8bae\u548c\u6d1e\u5bdf *\/}
\n <div className="insights-section">
\n <h3>\u4f18\u5316\u5efa\u8bae<\/h3>
\n <div className="insights-grid">
\n {stats.recommendations?.map((recommendation, index) => (
\n <div key={index} className="insight-card">
\n <div className="insight-icon">💡<\/div>
\n <div className="insight-content">
\n <p>{recommendation}<\/p>
\n <button
\n className="insight-action"
\n onClick={() => implementRecommendation(recommendation)}
\n >
\n \u5b9e\u65bd
\n <\/button>
\n <\/div>
\n <\/div>
\n ))}
\n <\/div>
\n <\/div>
\n <\/div>
\n );<\/p>\n
\/\/ \u8f85\u52a9\u51fd\u6570
\n function generateRateData() {
\n \/\/ \u751f\u6210\u6a21\u62df\u7684\u8d85\u65f6\u7387\u6570\u636e
\n const data = [];
\n for (let i = 0; i < 24; i++) {
\n data.push({
\n time: `${i}:00`,
\n rate: Math.random() * 15, \/\/ 0-15%\u7684\u8d85\u65f6\u7387
\n threshold: 10 \/\/ \u8b66\u544a\u9608\u503c10%
\n });
\n }
\n return data;
\n }<\/p>\n
function generateRadarData() {
\n \/\/ \u751f\u6210\u96f7\u8fbe\u56fe\u6570\u636e
\n return [
\n { subject: '\u7f51\u7edc\u8d28\u91cf', current: 85, target: 95 },
\n { subject: '\u670d\u52a1\u5668\u6027\u80fd', current: 90, target: 98 },
\n { subject: '\u5e94\u7528\u54cd\u5e94', current: 75, target: 95 },
\n { subject: '\u5ba2\u6237\u7aef\u4f53\u9a8c', current: 80, target: 90 },
\n { subject: '\u7cfb\u7edf\u7a33\u5b9a\u6027', current: 88, target: 99 },
\n { subject: '\u9519\u8bef\u6062\u590d', current: 70, target: 85 }
\n ];
\n }<\/p>\n
function viewEventDetails(event) {
\n \/\/ \u67e5\u770b\u4e8b\u4ef6\u8be6\u60c5
\n console.log('Event details:', event);
\n alert(`\u4e8b\u4ef6\u8be6\u60c5:\\\\n${JSON.stringify(event, null, 2)}`);
\n }<\/p>\n
function acknowledgeEvent(eventId) {
\n \/\/ \u786e\u8ba4\u4e8b\u4ef6
\n setRealtimeEvents(prev =>
\n prev.map(event =>
\n event.id === eventId ? { …event, acknowledged: true } : event
\n )
\n );
\n }<\/p>\n
function acknowledgeAnomaly(anomalyId) {
\n \/\/ \u786e\u8ba4\u5f02\u5e38
\n setAnomalies(prev =>
\n prev.map(anomaly =>
\n anomaly.id === anomalyId ? { …anomaly, acknowledged: true } : anomaly
\n )
\n );
\n }<\/p>\n
function investigateAnomaly(anomaly) {
\n \/\/ \u8c03\u67e5\u5f02\u5e38
\n console.log('Investigating anomaly:', anomaly);
\n window.open(`\/monitor\/investigate?anomalyId=${anomaly.id}`, '_blank');
\n }<\/p>\n
function muteAnomaly(anomalyId) {
\n \/\/ \u9759\u97f3\u5f02\u5e38
\n setAnomalies(prev => prev.filter(a => a.id !== anomalyId));
\n }<\/p>\n
function implementRecommendation(recommendation) {
\n \/\/ \u5b9e\u65bd\u5efa\u8bae
\n console.log('Implementing recommendation:', recommendation);
\n alert(`\u5f00\u59cb\u5b9e\u65bd: ${recommendation}`);
\n }<\/p>\n
function exportReport() {
\n \/\/ \u5bfc\u51fa\u62a5\u544a
\n const reportData = {
\n timestamp: new Date().toISOString(),
\n timeRange,
\n stats,
\n networkMetrics
\n };<\/p>\n
const blob = new Blob([JSON.stringify(reportData, null, 2)], {
\n type: 'application\/json'
\n });<\/p>\n
const url = URL.createObjectURL(blob);
\n const a = document.createElement('a');
\n a.href = url;
\n a.download = `timeout-report-${new Date().toISOString().slice(0, 10)}.json`;
\n a.click();
\n URL.revokeObjectURL(url);
\n }
\n}<\/p>\n
\/\/ CSS\u6837\u5f0f（\u5185\u8054\u793a\u4f8b）
\nconst styles = `
\n.timeout-dashboard {
\n padding: 20px;
\n max-width: 1600px;
\n margin: 0 auto;
\n font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
\n}<\/p>\n
.dashboard-header {
\n display: flex;
\n justify-content: space-between;
\n align-items: center;
\n margin-bottom: 30px;
\n padding-bottom: 20px;
\n border-bottom: 1px solid #e0e0e0;
\n}<\/p>\n
.header-left {
\n display: flex;
\n align-items: center;
\n gap: 15px;
\n}<\/p>\n
.header-icon {
\n color: #ff6b6b;
\n}<\/p>\n
.time-range-label {
\n background: #f0f0f0;
\n padding: 4px 12px;
\n border-radius: 16px;
\n font-size: 14px;
\n color: #666;
\n}<\/p>\n
.time-range-selector {
\n display: flex;
\n gap: 8px;
\n}<\/p>\n
.time-range-btn {
\n padding: 8px 16px;
\n border: 1px solid #ddd;
\n border-radius: 4px;
\n background: white;
\n cursor: pointer;
\n font-size: 14px;
\n}<\/p>\n
.time-range-btn.active {
\n background: #007bff;
\n color: white;
\n border-color: #007bff;
\n}<\/p>\n
.key-metrics-cards {
\n display: grid;
\n grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
\n gap: 20px;
\n margin-bottom: 30px;
\n}<\/p>\n
.metric-card {
\n background: white;
\n border-radius: 8px;
\n padding: 20px;
\n box-shadow: 0 2px 8px rgba(0,0,0,0.1);
\n display: flex;
\n align-items: center;
\n gap: 20px;
\n border-left: 4px solid;
\n}<\/p>\n
.metric-card.critical { border-left-color: #ff6b6b; }
\n.metric-card.warning { border-left-color: #ffa726; }
\n.metric-card.info { border-left-color: #42a5f5; }
\n.metric-card.success { border-left-color: #66bb6a; }<\/p>\n
.metric-icon {
\n background: #f5f5f5;
\n padding: 12px;
\n border-radius: 8px;
\n display: flex;
\n align-items: center;
\n justify-content: center;
\n}<\/p>\n
.metric-card.critical .metric-icon { background: #ffebee; color: #ff6b6b; }
\n.metric-card.warning .metric-icon { background: #fff3e0; color: #ffa726; }
\n.metric-card.info .metric-icon { background: #e3f2fd; color: #42a5f5; }
\n.metric-card.success .metric-icon { background: #e8f5e8; color: #66bb6a; }<\/p>\n
.metric-value {
\n font-size: 32px;
\n font-weight: bold;
\n margin: 8px 0;
\n}<\/p>\n
.metric-trend {
\n font-size: 14px;
\n color: #666;
\n}<\/p>\n
.network-metrics {
\n background: white;
\n border-radius: 8px;
\n padding: 20px;
\n margin-bottom: 30px;
\n box-shadow: 0 2px 8px rgba(0,0,0,0.1);
\n}<\/p>\n
.network-cards {
\n display: grid;
\n grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
\n gap: 15px;
\n margin-top: 15px;
\n}<\/p>\n
.network-card {
\n display: flex;
\n align-items: center;
\n gap: 10px;
\n padding: 15px;
\n background: #f8f9fa;
\n border-radius: 6px;
\n border: 1px solid #e9ecef;
\n}<\/p>\n
.network-label {
\n flex: 1;
\n font-size: 14px;
\n color: #666;
\n}<\/p>\n
.network-value {
\n font-weight: bold;
\n font-size: 16px;
\n}<\/p>\n
.network-value.warning { color: #ffa726; }
\n.network-value.critical { color: #ff6b6b; }<\/p>\n
.charts-section {
\n margin-bottom: 30px;
\n}<\/p>\n
.chart-row {
\n display: grid;
\n grid-template-columns: repeat(auto-fit, minmax(600px, 1fr));
\n gap: 20px;
\n margin-bottom: 20px;
\n}<\/p>\n
.chart-container {
\n background: white;
\n border-radius: 8px;
\n padding: 20px;
\n box-shadow: 0 2px 8px rgba(0,0,0,0.1);
\n}<\/p>\n
.realtime-events-section {
\n background: white;
\n border-radius: 8px;
\n padding: 20px;
\n margin-bottom: 30px;
\n box-shadow: 0 2px 8px rgba(0,0,0,0.1);
\n}<\/p>\n
.events-table-container {
\n overflow-x: auto;
\n margin-top: 15px;
\n}<\/p>\n
.events-table {
\n width: 100%;
\n border-collapse: collapse;
\n}<\/p>\n
.events-table th {
\n text-align: left;
\n padding: 12px;
\n background: #f8f9fa;
\n border-bottom: 2px solid #dee2e6;
\n font-weight: 600;
\n color: #495057;
\n}<\/p>\n
.events-table td {
\n padding: 12px;
\n border-bottom: 1px solid #dee2e6;
\n}<\/p>\n
.event-row.severity-high {
\n background: #fff5f5;
\n}<\/p>\n
.event-row.severity-medium {
\n background: #fff9db;
\n}<\/p>\n
.event-row.severity-low {
\n background: #f8f9fa;
\n}<\/p>\n
.endpoint-cell code {
\n background: #f1f3f5;
\n padding: 2px 6px;
\n border-radius: 4px;
\n font-family: monospace;
\n font-size: 12px;
\n}<\/p>\n
.duration-badge {
\n background: #e7f5ff;
\n color: #1971c2;
\n padding: 4px 8px;
\n border-radius: 4px;
\n font-size: 12px;
\n font-weight: 500;
\n}<\/p>\n
.cause-badge {
\n padding: 4px 8px;
\n border-radius: 4px;
\n font-size: 12px;
\n font-weight: 500;
\n}<\/p>\n
.cause-badge.cause-network { background: #e3f2fd; color: #1976d2; }
\n.cause-badge.cause-server { background: #f3e5f5; color: #7b1fa2; }
\n.cause-badge.cause-application { background: #e8f5e8; color: #2e7d32; }
\n.cause-badge.cause-client { background: #fff3e0; color: #ef6c00; }<\/p>\n
.severity-badge {
\n padding: 4px 8px;
\n border-radius: 4px;
\n font-size: 12px;
\n font-weight: 500;
\n}<\/p>\n
.severity-badge.severity-high { background: #ffebee; color: #c62828; }
\n.severity-badge.severity-medium { background: #fff3e0; color: #ef6c00; }
\n.severity-badge.severity-low { background: #e8f5e8; color: #2e7d32; }<\/p>\n
.action-btn {
\n padding: 6px 12px;
\n margin: 0 4px;
\n border: none;
\n border-radius: 4px;
\n cursor: pointer;
\n font-size: 12px;
\n}<\/p>\n
.action-btn.view-details {
\n background: #e3f2fd;
\n color: #1976d2;
\n}<\/p>\n
.action-btn.acknowledge {
\n background: #e8f5e8;
\n color: #2e7d32;
\n}<\/p>\n
.anomalies-section {
\n background: white;
\n border-radius: 8px;
\n padding: 20px;
\n margin-bottom: 30px;
\n box-shadow: 0 2px 8px rgba(0,0,0,0.1);
\n border: 2px solid #ffebee;
\n}<\/p>\n
.anomaly-card {
\n background: #fff5f5;
\n border: 1px solid #ffcdd2;
\n border-radius: 6px;
\n padding: 15px;
\n margin-bottom: 10px;
\n}<\/p>\n
.anomaly-header {
\n display: flex;
\n justify-content: space-between;
\n margin-bottom: 10px;
\n}<\/p>\n
.anomaly-type {
\n font-weight: bold;
\n color: #c62828;
\n}<\/p>\n
.anomaly-time {
\n font-size: 12px;
\n color: #666;
\n}<\/p>\n
.anomaly-details {
\n background: white;
\n padding: 10px;
\n border-radius: 4px;
\n margin-top: 10px;
\n font-size: 12px;
\n max-height: 200px;
\n overflow-y: auto;
\n}<\/p>\n
.anomaly-actions {
\n display: flex;
\n gap: 10px;
\n margin-top: 15px;
\n}<\/p>\n
.btn {
\n padding: 8px 16px;
\n border: none;
\n border-radius: 4px;
\n cursor: pointer;
\n font-size: 14px;
\n}<\/p>\n
.btn-primary {
\n background: #1976d2;
\n color: white;
\n}<\/p>\n
.btn-secondary {
\n background: #f5f5f5;
\n color: #333;
\n}<\/p>\n
.btn-tertiary {
\n background: transparent;
\n color: #666;
\n border: 1px solid #ddd;
\n}<\/p>\n
.insights-section {
\n background: white;
\n border-radius: 8px;
\n padding: 20px;
\n box-shadow: 0 2px 8px rgba(0,0,0,0.1);
\n}<\/p>\n
.insights-grid {
\n display: grid;
\n grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
\n gap: 20px;
\n margin-top: 20px;
\n}<\/p>\n
.insight-card {
\n display: flex;
\n gap: 15px;
\n padding: 15px;
\n background: #f8f9fa;
\n border-radius: 6px;
\n border-left: 4px solid #42a5f5;
\n}<\/p>\n
.insight-icon {
\n font-size: 24px;
\n}<\/p>\n
.insight-content {
\n flex: 1;
\n}<\/p>\n
.insight-action {
\n margin-top: 10px;
\n padding: 6px 12px;
\n background: #42a5f5;
\n color: white;
\n border: none;
\n border-radius: 4px;
\n cursor: pointer;
\n font-size: 12px;
\n}
\n`;<\/p>\n
\/\/ \u6dfb\u52a0\u5230\u6587\u6863
\nconst styleSheet = document.createElement('style');
\nstyleSheet.textContent = styles;
\ndocument.head.appendChild(styleSheet)<\/p>\n","protected":false},"excerpt":{"rendered":"
\u7b2c20\u7ae0：405 Method Not Allowed – \u65b9\u6cd5\u4e0d\u5141\u8bb8\u6df1\u5ea6\u5206\u679020.1 \u5b9a\u4e49\u4e0e\u8bed\u4e49405 Method Not Allowed\u00a0\u72b6\u6001\u7801\u8868\u793a\u8bf7\u6c42\u884c\u4e2d\u6307\u5b9a\u7684\u65b9\u6cd5\u5bf9\u8bf7\u6c42URI\u6807\u8bc6\u7684\u8d44\u6e90\u662f\u5df2\u77e5\u7684，\u4f46\u4e0d\u88ab\u76ee\u6807\u8d44\u6e90\u652f\u6301\u3002\u670d\u52a1\u5668\u5fc5\u987b\u751f\u6210\u4e00\u4e2a\u00a0Allow\u00a0\u54cd\u5e94\u5934\u5b57\u6bb5，\u5305\u542b\u76ee\u6807\u8d44\u6e90\u5f53\u524d\u652f\u6301\u7684\u65b9\u6cd5\u5217\u8868\u3002\u6838\u5fc3\u8bed\u4e49：\u670d\u52a1\u5668\u7406\u89e3\u8bf7\u6c42，\u4f46\u660e\u786e\u62d2\u7edd\u6267\u884c\u8be5\u65b9\u6cd5\u4e0e501（\u672a\u5b9e\u73b0）\u4e0d\u540c：<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[99,43],"topic":[],"class_list":["post-59721","post","type-post","status-publish","format-standard","hentry","category-server","tag-java","tag-43"],"yoast_head":"\n