AI 에이전트가 실시간으로 수백 개의 도구를 호출하는 시대, 운영 담당자는 어떤 도구가 얼마나 사용되었는지, 어떤 매개변수로 실행되었는지, 승인 체인은 어떻게 흘렀는지 파악해야 합니다. 저는 최근 이커머스 플랫폼에서 AI 고객 서비스 봇의 MCP 도구 호출량을 관리하기 위해 HolySheep AI의 감사 기능을 도입했는데, 수작업으로 3일 걸리던 월간 보고서를 자동화하여 15분 만에 생성할 수 있게 되었습니다.

이 튜토리얼에서는 HolySheep AI의 MCP 도구 호출 감사 기능을 활용하여 도구 이름별·매개변수별·승인 체인별·예외 결과별로 분류된 관리자 월간 보고서를 생성하는 전체 과정을 다룹니다.

왜 MCP 도구 호출 감사가 중요한가

AI 에이전트가 외부 도구를 호출할 때마다 보안·비용·품질 측면에서 검증이 필요합니다. HolySheep AI는 이러한 호출을 실시간으로 추적하고审计 Logs를 구조화하여 관리자 친화적인 보고서로 제공합니다.

핵심 감사 지표

사전 준비: HolySheep AI 프로젝트 설정

먼저 HolySheep AI에서 MCP 감사 기능을 활성화하고 필요한 API 키를 발급받습니다.

# HolySheep AI에 로그인 후 API Keys 메뉴에서 새 키 발급

base_url: https://api.holysheep.ai/v1


발급받은 키를 환경변수로 저장


export HOLYSHEEP_API_KEY="YOUR_HOLYSHEEP_API_KEY"


프로젝트 생성 (MCP 감사 기능 활성화)

curl -X POST https://api.holysheep.ai/v1/projects \
  -H "Authorization: Bearer $HOLYSHEEP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "ecommerce-mcp-audit",
    "audit_enabled": true,
    "mcp_tools": ["product_search", "order_lookup", "inventory_check", "customer_profile"]
  }'
# Node.js 환경에서 HolySheep AI SDK 설치
npm install @holysheepai/sdk


SDK 초기화 및 MCP 감사 클라이언트 설정

import { HolySheepClient } from '@holysheepai/sdk';

const client = new HolySheepClient({
  apiKey: process.env.HOLYSHEEP_API_KEY,
  baseUrl: 'https://api.holysheep.ai/v1',
  audit: {
    enabled: true,
    logLevel: 'detailed',
    captureParams: true,
    captureApprovalChain: true
  }
});

// 감사 설정 확인
const auditConfig = await client.audit.getConfig();
console.log('감사 기능 상태:', auditConfig);

MCP 도구 호출 감사 Logs 수집하기

이커머스 AI 고객 서비스 봇에서 발생하는 MCP 도구 호출을 감사 Logs로 수집하는 예제입니다.

# Python 예제: HolySheep AI MCP 감사 Logs 수집
import requests
from datetime import datetime, timedelta

HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
BASE_URL = "https://api.holysheep.ai/v1"

def fetch_mcp_audit_logs(start_date: str, end_date: str, filters: dict = None):
    """
    HolySheep AI에서 MCP 도구 호출 감사 Logs 조회
    
    Args:
        start_date: ISO 형식 시작 날짜 (예: 2026-04-01)
        end_date: ISO 형식 종료 날짜 (예: 2026-04-30)
        filters: 필터 조건 (tool_name, status, approval_chain_id 등)
    """
    endpoint = f"{BASE_URL}/audit/mcp/logs"
    
    headers = {
        "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
        "Content-Type": "application/json"
    }
    
    params = {
        "start_date": start_date,
        "end_date": end_date,
        "include_params": True,
        "include_approval_chain": True,
        "include_exceptions": True
    }
    
    if filters:
        params.update(filters)
    
    response = requests.get(endpoint, headers=headers, params=params)
    
    if response.status_code == 200:
        return response.json()
    else:
        raise Exception(f"감사 Logs 조회 실패: {response.status_code} - {response.text}")


2026년 4월 전체 Logs 수집

april_logs = fetch_mcp_audit_logs(
    start_date="2026-04-01",
    end_date="2026-04-30"
)

print(f"수집된 감사 Logs: {april_logs['total_count']}건")
print(f"총 도구 호출: {april_logs['summary']['total_calls']}회")
print(f"예외 발생: {april_logs['summary']['exception_count']}건")
# TypeScript 예제: 도구별 호출 통계 분석
interface MCPToolCall {
  id: string;
  tool_name: string;
  params: Record;
  approval_chain: ApprovalChain;
  status: 'success' | 'failed' | 'pending';
  exception?: ExceptionInfo;
  timestamp: string;
  cost: number;
}

interface AuditReport {
  tool_summary: Map;
  param_distribution: Map;
  approval_metrics: ApprovalMetrics;
  exception_analysis: ExceptionAnalysis;
}

async function generateMonthlyAuditReport(
  client: HolySheepClient,
  month: string
): Promise {
  // 1단계: 원본 Logs 수집
  const rawLogs = await client.audit.mcp.getLogs({
    period: month,
    granularity: 'hourly'
  });
  
  // 2단계: 도구별 집계
  const toolSummary = new Map();
  const paramDistribution = new Map();
  
  for (const log of rawLogs.logs as MCPToolCall[]) {
    // 도구별 통계
    if (!toolSummary.has(log.tool_name)) {
      toolSummary.set(log.tool_name, {
        totalCalls: 0,
        successCount: 0,
        failedCount: 0,
        avgLatency: 0,
        totalCost: 0
      });
    }
    
    const stats = toolSummary.get(log.tool_name)!;
    stats.totalCalls++;
    stats.totalCost += log.cost;
    
    if (log.status === 'success') {
      stats.successCount++;
    } else {
      stats.failedCount++;
    }
    
    // 매개변수 분포 분석
    analyzeParamDistribution(log.tool_name, log.params, paramDistribution);
  }
  
  // 3단계: 승인 체인 메트릭스
  const approvalMetrics = calculateApprovalMetrics(rawLogs.logs);
  
  // 4단계: 예외 분석
  const exceptionAnalysis = analyzeExceptions(rawLogs.logs);
  
  return {
    tool_summary: toolSummary,
    param_distribution: paramDistribution,
    approval_metrics: approvalMetrics,
    exception_analysis: exceptionAnalysis
  };
}

관리자 월간 보고서 생성 템플릿

수집된 감사 Logs를 기반으로 관리자 친화적인 월간 보고서를 생성합니다.

# Python: 관리자 월간 보고서 생성기
from datetime import datetime
from collections import Counter, defaultdict
import json

class MCPAuditReportGenerator:
    def __init__(self, audit_logs: dict):
        self.logs = audit_logs['logs']
        self.summary = audit_logs['summary']
        
    def generate_management_report(self) -> dict:
        """관리자용 월간 보고서 생성"""
        return {
            "report_period": self.summary['period'],
            "generated_at": datetime.now().isoformat(),
            "executive_summary": self._executive_summary(),
            "tool_usage_analysis": self._tool_usage_analysis(),
            "parameter_insights": self._parameter_insights(),
            "approval_chain_report": self._approval_chain_report(),
            "exception_report": self._exception_report(),
            "cost_allocation": self._cost_allocation(),
            "recommendations": self._generate_recommendations()
        }
    
    def _executive_summary(self) -> dict:
        """경영진 요약"""
        total_calls = self.summary['total_calls']
        unique_tools = len(set(log['tool_name'] for log in self.logs))
        exception_rate = (
            self.summary['exception_count'] / total_calls * 100
            if total_calls > 0 else 0
        )
        
        return {
            "total_mcp_calls": total_calls,
            "unique_tools_used": unique_tools,
            "exception_rate_percent": round(exception_rate, 2),
            "total_api_cost_usd": self.summary['total_cost'],
            "peak_hour": self._find_peak_hour(),
            "health_status": "healthy" if exception_rate < 5 else "warning"
        }
    
    def _tool_usage_analysis(self) -> list:
        """도구별 사용량 분석"""
        tool_counts = Counter(log['tool_name'] for log in self.logs)
        tool_costs = defaultdict(float)
        tool_exceptions = defaultdict(int)
        
        for log in self.logs:
            tool_costs[log['tool_name']] += log.get('cost', 0)
            if log.get('exception'):
                tool_exceptions[log['tool_name']] += 1
        
        return [
            {
                "tool_name": tool,
                "call_count": count,
                "call_percentage": round(count / sum(tool_counts.values()) * 100, 2),
                "total_cost_usd": round(tool_costs[tool], 4),
                "exception_count": tool_exceptions[tool],
                "exception_rate_percent": round(
                    tool_exceptions[tool] / count * 100, 2
                ) if count > 0 else 0
            }
            for tool, count in tool_counts.most_common(20)
        ]
    
    def _parameter_insights(self) -> dict:
        """매개변수 사용 패턴 분석"""
        param_patterns = defaultdict(lambda: defaultdict(int))
        
        for log in self.logs:
            params = log.get('params', {})
            # 주요 매개변수 추출 (도구별로 다름)
            if 'search_query' in params:
                query_type = self._classify_search_query(params['search_query'])
                param_patterns[log['tool_name']][query_type] += 1
            if 'category' in params:
                param_patterns[log['tool_name']][params['category']] += 1
        
        return dict(param_patterns)
    
    def _approval_chain_report(self) -> dict:
        """승인 체인 분석"""
        chain_stats = defaultdict(lambda: {
            'total': 0,
            'auto_approved': 0,
            'manual_review': 0,
            'rejected': 0,
            'avg_approval_time_ms': 0
        })
        
        for log in self.logs:
            chain = log.get('approval_chain', {})
            chain_id = chain.get('chain_type', 'unknown')
            stats = chain_stats[chain_id]
            
            stats['total'] += 1
            if chain.get('status') == 'auto_approved':
                stats['auto_approved'] += 1
            elif chain.get('status') == 'manual_review':
                stats['manual_review'] += 1
            elif chain.get('status') == 'rejected':
                stats['rejected'] += 1
            
            stats['avg_approval_time_ms'] += chain.get('approval_time_ms', 0)
        
        # 평균 계산
        for chain_id, stats in chain_stats.items():
            if stats['total'] > 0:
                stats['avg_approval_time_ms'] = round(
                    stats['avg_approval_time_ms'] / stats['total'], 2
                )
        
        return dict(chain_stats)
    
    def _exception_report(self) -> dict:
        """예외 결과 분석"""
        exceptions = [log for log in self.logs if log.get('exception')]
        
        exception_types = Counter(
            exc.get('type', 'unknown') for log in exceptions 
            for exc in [log['exception']]
        )
        
        return {
            "total_exceptions": len(exceptions),
            "exceptions_by_type": dict(exception_types.most_common(10)),
            "top_exception_tools": [
                exc['tool_name'] for exc in exceptions
            ][:5],
            "severity_distribution": {
                "critical": len([e for e in exceptions if e['exception'].get('severity') == 'critical']),
                "warning": len([e for e in exceptions if e['exception'].get('severity') == 'warning']),
                "info": len([e for e in exceptions if e['exception'].get('severity') == 'info'])
            }
        }
    
    def _cost_allocation(self) -> list:
        """비용 배분 보고서"""
        tool_costs = defaultdict(float)
        for log in self.logs:
            tool_costs[log['tool_name']] += log.get('cost', 0)
        
        total_cost = sum(tool_costs.values())
        
        return [
            {
                "tool_name": tool,
                "cost_usd": round(cost, 4),
                "cost_percentage": round(cost / total_cost * 100, 2) if total_cost > 0 else 0
            }
            for tool, cost in sorted(tool_costs.items(), key=lambda x: -x[1])
        ]
    
    def _generate_recommendations(self) -> list:
        """개선 권고사항"""
        recommendations = []
        
        # 높은 예외율 도구 체크
        tool_stats = self._tool_usage_analysis()
        high_exception_tools = [
            t for t in tool_stats if t['exception_rate_percent'] > 10
        ]
        
        if high_exception_tools:
            recommendations.append({
                "priority": "high",
                "category": "exception_management",
                "description": f"다음 도구들의 예외율이 10%를 초과합니다: {', '.join([t['tool_name'] for t in high_exception_tools])}",
                "action": "도구 로직 검토 및 에러 처리 개선 권장"
            })
        
        # 수동 승인过多 체크
        approval_stats = self._approval_chain_report()
        manual_review_heavy = [
            chain for chain, stats in approval_stats.items()
            if stats.get('manual_review', 0) / stats['total'] > 0.3 if stats['total'] > 0
        ]
        
        if manual_review_heavy:
            recommendations.append({
                "priority": "medium",
                "category": "approval_optimization",
                "description": "수동 승인이 30%를 초과하는 승인 체인이 있습니다",
                "action": "승인 규칙 세분화 및 자동 승인 조건 확대 권장"
            })
        
        return recommendations


보고서 생성 실행

generator = MCPAuditReportGenerator(april_logs)
management_report = generator.generate_management_report()


JSON 파일로 저장

with open('mcp_audit_report_2026_04.json', 'w', encoding='utf-8') as f:
    json.dump(management_report, f, ensure_ascii=False, indent=2)

print("월간 감사 보고서 생성 완료!")
print(json.dumps(management_report['executive_summary'], indent=2))

보고서 출력 형식: Markdown → HTML 변환

# Python: 관리자 보고서를 HTML 대시보드로 변환
from datetime import datetime

def generate_html_dashboard(report: dict) -> str:
    """관리자 대시보드용 HTML 보고서 생성"""
    
    html_template = """



    
    MCP 도구 호출 감사 월간 보고서
    


    

        
MCP 도구 호출 감사 월간 보고서

        
기간: {period} | 생성일시: {generated_at}

        
상태: {health_status}

    

    
    

        

            
{total_calls:,}

            
총 도구 호출

        

        

            
{unique_tools}

            
사용된 도구 수

        

        

            
{exception_rate}%

            
예외 발생률

        

        

            
${total_cost}

            
총 API 비용

        

    

    
    

        
도구별 사용량

        
            {tool_rows}
        

            

                도구 이름
                호출 횟수
                비율
                비용 (USD)
                예외 발생
                예외율
            

    

    
    

        
승인 체인 현황

        
            {approval_rows}
        

            

                승인 유형
                총 건수
                자동 승인
                수동 검토
                거부
                평균 처리 시간
            

    

    
    

        
예외 분석

        
총 예외 건수: {total_exceptions}

        
            {exception_rows}
        

            

                예외 유형
                발생 건수
            

    

    
    

        
개선 권고사항

        
    
            {recommendation_rows}
        

    



"""
    
    # 동적 데이터 치환
    exec_summary = report['executive_summary']
    health_class = "status-healthy" if exec_summary['health_status'] == 'healthy' else "status-warning"
    
    tool_rows = ""
    for tool in report['tool_usage_analysis']:
        exception_class = "exception-critical" if tool['exception_rate_percent'] > 10 else "exception-warning"
        tool_rows += f"""
            
                {tool['tool_name']}
                {tool['call_count']:,}
                {tool['call_percentage']}%
                ${tool['total_cost_usd']:.4f}
                {tool['exception_count']}
                {tool['exception_rate_percent']}%
            
        """
    
    approval_rows = ""
    for chain_type, stats in report['approval_chain_report'].items():
        approval_rows += f"""
            
                {chain_type}
                {stats['total']}
                {stats['auto_approved']}
                {stats['manual_review']}
                {stats['rejected']}
                {stats['avg_approval_time_ms']}ms
            
        """
    
    exception_rows = ""
    for exc_type, count in report['exception_report']['exceptions_by_type'].items():
        exception_rows += f"{exc_type}{count}"
    
    recommendation_rows = ""
    for rec in report['recommendations']:
        priority_class = "exception-critical" if rec['priority'] == 'high' else "exception-warning"
        recommendation_rows += f"
  • [{rec['priority'].upper()}] {rec['description']}
    권장 조치: {rec['action']}
    • "
    
    return html_template.format(
        period=exec_summary['report_period'] if 'report_period' in exec_summary else 'N/A',
        generated_at=report['generated_at'],
        health_status=exec_summary['health_status'],
        total_calls=exec_summary['total_mcp_calls'],
        unique_tools=exec_summary['unique_tools_used'],
        exception_rate=exec_summary['exception_rate_percent'],
        total_cost=round(exec_summary['total_api_cost_usd'], 2),
        tool_rows=tool_rows,
        approval_rows=approval_rows,
        total_exceptions=report['exception_report']['total_exceptions'],
        exception_rows=exception_rows,
        recommendation_rows=recommendation_rows
    )


    HTML 대시보드 생성
    
html_dashboard = generate_html_dashboard(management_report)

with open('mcp_audit_dashboard_2026_04.html', 'w', encoding='utf-8') as f:
    f.write(html_dashboard)

print("HTML 대시보드 생성 완료: mcp_audit_dashboard_2026_04.html")

    실시간 대시보드: WebSocket 스트리밍

    관리자가 실시간으로 MCP 도구 호출 현황을 모니터링할 수 있는 WebSocket 기반 스트리밍 대시보드입니다.

    # Node.js: WebSocket 기반 실시간 감사 대시보드
import { WebSocketServer } from 'ws';
import { HolySheepClient } from '@holysheepai/sdk';

const wss = new WebSocketServer({ port: 8080 });
const holySheep = new HolySheepClient({
  apiKey: process.env.HOLYSHEEP_API_KEY,
  baseUrl: 'https://api.holysheep.ai/v1'
});

// 실시간 Metrics 버퍼
const metricsBuffer = {
  callsPerMinute: [],
  toolDistribution: {},
  exceptionCount: 0,
  totalCost: 0
};

// HolySheep AI WebSocket 스트림 구독
async function subscribeToAuditStream() {
  const stream = await holySheep.audit.mcp.subscribe({
    events: ['call_start', 'call_complete', 'exception'],
    includePayload: true
  });
  
  stream.on('data', (event) => {
    // 실시간 Metrics 업데이트
    updateMetrics(event);
    
    // 연결된 모든 클라이언트에 브로드캐스트
    const message = JSON.stringify({
      type: event.type,
      data: transformForDashboard(event),
      timestamp: Date.now()
    });
    
    wss.clients.forEach((client) => {
      if (client.readyState === 1) { // WebSocket.OPEN
        client.send(message);
      }
    });
  });
  
  stream.on('error', (error) => {
    console.error('스트림 오류:', error);
    // 자동 재연결 로직
    setTimeout(subscribeToAuditStream, 5000);
  });
}

function updateMetrics(event: AuditEvent) {
  const now = Date.now();
  
  switch (event.type) {
    case 'call_complete':
      metricsBuffer.callsPerMinute.push({ time: now, count: 1 });
      metricsBuffer.toolDistribution[event.tool_name] = 
        (metricsBuffer.toolDistribution[event.tool_name] || 0) + 1;
      metricsBuffer.totalCost += event.cost;
      break;
    case 'exception':
      metricsBuffer.exceptionCount++;
      break;
  }
  
  // 1분 이상된 데이터 정리
  const cutoff = now - 60000;
  metricsBuffer.callsPerMinute = metricsBuffer.callsPerMinute.filter(
    m => m.time > cutoff
  );
}

function transformForDashboard(event: AuditEvent) {
  return {
    toolName: event.tool_name,
    params: event.params,
    status: event.status,
    cost: event.cost,
    approvalChain: event.approval_chain,
    exception: event.exception
  };
}

// WebSocket 연결 관리
wss.on('connection', (ws, req) => {
  console.log('새 대시보드 클라이언트 연결:', req.socket.remoteAddress);
  
  // 초기 Metrics 전송
  ws.send(JSON.stringify({
    type: 'initial_state',
    data: metricsBuffer,
    timestamp: Date.now()
  }));
  
  ws.on('close', () => {
    console.log('대시보드 클라이언트 연결 해제');
  });
});

// 스트리밍 시작
subscribeToAuditStream().catch(console.error);

console.log('실시간 감사 대시보드 서버 실행 중: ws://localhost:8080');

    HolySheep AI vs 직접 구현: 기능 비교

    기능 HolySheep AI 감사 기능 직접 구현 (ELK Stack) 직접 구현 (Datadog)
    기본 비용 월 $29~ (프로젝트 기반) EC2 + Elasticsearch: 월 $200~ 월 $500~ (프로)
    설정 시간 15분 2~3일 1~2일
    MCP 도구 자동 인식 ✓ 네이티브 지원 커스텀 파서 필요 커스텀 통합 필요
    승인 체인 추적 ✓ 내장 별도 구현 별도 구현
    관리자 보고서 자동 생성 ✓ 템플릿 제공 수동 대시보드 구성 수동 대시보드 구성
    예외 패턴 분석 AI 기반 자동 분류 수동 룰 설정 수동 룰 설정
    실시간 WebSocket 스트리밍 ✓ 기본 제공 추가 개발 필요 추가 비용
    한국어 지원 ✓ 완전 지원 커스텀 번역 커스텀 번역
    단일 API 키로 모든 모델 ✓ 게이트웨이 통합 별도 키 관리 별도 키 관리

    이런 팀에 적합 / 비적합

    ✅ HolySheep AI MCP 감사가 적합한 팀

    ❌ HolySheep AI MCP 감사가 불필요한 경우

    가격과 ROI

    플랜 월간 비용 감사 Logs 저장 보고서 생성 적합한 규모
    Developer $29 30일 월 10회 개인/팀 프로토타입
    Growth $99 90일 월 100회 중규모 프로덕션
    Enterprise $299~ 1년+ 무제한 대규모/다중 팀

    ROI 분석 (이커머스 예시)

    왜 HolySheep를 선택해야 하나

    1. 단일 API 키로 모든 주요 모델 통합: GPT-4.1, Claude Sonnet 4.5, Gemini 2.5 Flash, DeepSeek V3.2 등을 base_url 하나로 관리
    2. 네이티브 MCP 감사 기능: 도구 호출Logs, 승인 체인 추적, 예외 분석을 별도 설정 없이 즉시 사용
    3. 로컬 결제 지원: 해외 신용카드 없이 원활한 결제가 가능하여 글로벌 개발자도 쉽게 접근
    4. 개발자 친화적 문서: Python, Node.js, TypeScript SDK와 상세 튜토리얼 제공
    5. 무료 크레딧 제공: 가입 시 체험 크레딧으로 프로덕션 이전 테스트 가능

    자주 발생하는 오류와 해결책

    오류 1: "401 Unauthorized - Invalid API Key"

    API 키가 올바르지 않거나 만료된 경우 발생합니다.

    # 해결 방법: 올바른 API 키 확인 및 환경변수 재설정


    1. HolySheep AI 대시보드에서 API Keys 메뉴 확인
    

    https://www.holysheep.ai/dashboard/api-keys
    


    2. 환경변수 재설정
    
export HOLYSHEEP_API_KEY="hs_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxx"


    3. 키 유효성 검증
    
curl -X GET https://api.holysheep.ai/v1/auth/verify \
  -H "Authorization: Bearer $HOLYSHEEP_API_KEY"


    4. 응답 확인
    

    {"valid": true, "plan": "growth", "expires_at": "2027-01-01T00:00:00Z"}

    오류 2: "audit_enabled flag required for MCP logs"

    프로젝트에서 감사 기능이 활성화되지 않은 경우 발생합니다.

    # 해결 방법: 프로젝트 감사 기능 활성화

curl -X PATCH https://api.holysheep.ai/v1/projects/{project_id} \
  -H "Authorization: Bearer $HOLYSHEEP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "audit_enabled": true,
    "audit_settings": {
      "mcp_tools": ["product_search", "order_lookup", "inventory_check"],
      "log_level": "detailed",
      "retention_days": 90
    }
  }'


    SDK로 활성화하는 경우
    
await client.audit.enable({
  projectId: 'your-project-id',
  options: {
    captureParams: true,
    captureApprovalChain: true,
    captureExceptions: true,
    sampleRate: 1.0 // 100% 수집
  }
});

    오류 3: "Rate limit exceeded for audit logs endpoint"

    감사 Logs 조회 시 요청 빈도가 제한을 초과한 경우입니다.

    # 해결 방법: 요청 간격 조정 및 배치 쿼리 사용

import time
from ratelimit import limits, sleep_and_retry

@sleep_and_retry
@limits(calls=100, period=60)  # 분당 100회 제한
def fetch_audit_logs_with_retry(endpoint, params):
    response = requests.get(endpoint, headers=headers, params=params)
    
    if response.status_code == 429:
        retry_after = int(response.headers.get('Retry-After', 60))
        print(f"Rate limit 도달. {retry_after}초 후 재시도...")
        time.sleep(retry_after)
        return fetch_audit_logs_with_retry(endpoint, params)
    
    return response.json()

#

    관련 리소스
    관련 문서