log-collector-async 1.1.0__py3-none-any.whl

log_collector_async-1.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+log_collector/__init__.py,sha256=mMKUApIhihjC2dUpFqDIETlsv6fyTHSW3Wi-xmr9y6Q,235
+log_collector/async_client.py,sha256=5C7GMpleOWyLc66MMfGtORHIiOSB-cb7lW8mTsCRyw0,23029
+tests/__init__.py,sha256=nIjtuR9Yjo1I5YSO71TTufw2_pFXvJn0rKNEorpYaJE,23
+tests/test_async_client.py,sha256=j-dtf9ayL3kaVctYA9IOHsyFzj57a-xRS1i_Az8MfAg,10155
+tests/test_integration.py,sha256=5dF5GHZBtiyDWZjQBDSFzZ_ZvfiESBb0sohGMx_F8iw,12318
+tests/test_performance.py,sha256=zXMNz4QjDgXgU1i_5T-n_BeDb3NI6dafKva1-DfLUBA,4852
+log_collector_async-1.1.0.dist-info/METADATA,sha256=IoGHUgWjsOlb1XCQSnpMteZpFvd4vx1D1a_N-0Wy1SI,22325
+log_collector_async-1.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+log_collector_async-1.1.0.dist-info/top_level.txt,sha256=4fOfJ7egtA7Xk4uHLPZt1hEfWk7w2i3DdkXWskkcPag,20
+log_collector_async-1.1.0.dist-info/RECORD,,

log_collector_async-1.1.0.dist-info/WHEEL

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

log_collector_async-1.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+log_collector
+tests

tests/__init__.py

@@ -0,0 +1 @@
+# Python tests package

tests/test_async_client.py

@@ -0,0 +1,292 @@
+"""
+단위 테스트: AsyncLogClient 기본 동작 검증
+로그 서버 없이도 실행 가능한 테스트
+"""
+import pytest
+import time
+from log_collector import AsyncLogClient
+
+
+def test_client_initialization():
+    """클라이언트 초기화 테스트"""
+    client = AsyncLogClient("http://localhost:8000")
+    assert client is not None
+    assert client.server_url == "http://localhost:8000"
+
+
+def test_log_queueing():
+    """로그 큐잉 테스트 (블로킹 없음)"""
+    client = AsyncLogClient("http://localhost:8000", batch_size=1000)
+
+    start = time.time()
+    client.log("INFO", "test message", test_id="queue_test")
+    elapsed = time.time() - start
+
+    # 앱 블로킹 < 0.001초 확인
+    assert elapsed < 0.001, f"Blocking time {elapsed}s exceeded 0.001s"
+
+
+def test_batch_size_option():
+    """배치 크기 옵션 테스트"""
+    client = AsyncLogClient("http://localhost:8000", batch_size=500)
+    assert client.batch_size == 500
+
+
+def test_flush_interval_option():
+    """Flush 간격 옵션 테스트"""
+    client = AsyncLogClient("http://localhost:8000", flush_interval=2.0)
+    assert client.flush_interval == 2.0
+
+
+def test_multiple_log_levels():
+    """다양한 로그 레벨 테스트"""
+    client = AsyncLogClient("http://localhost:8000", batch_size=100)
+
+    # 다양한 레벨 로그 생성
+    client.log("INFO", "info message")
+    client.log("WARN", "warning message")
+    client.log("ERROR", "error message")
+    client.log("DEBUG", "debug message")
+    client.log("FATAL", "fatal message")
+
+    # 에러 없이 실행되어야 함
+    assert True
+
+
+def test_metadata_parameters():
+    """메타데이터 전달 테스트"""
+    client = AsyncLogClient("http://localhost:8000", batch_size=100)
+
+    # 임의의 메타데이터 전달
+    client.log("INFO", "test", user_id=123, action="login", success=True)
+
+    # 에러 없이 실행되어야 함
+    assert True
+
+
+def test_service_name_option():
+    """서비스 이름 옵션 테스트"""
+    client = AsyncLogClient("http://localhost:8000", service="test-service")
+    # AsyncLogClient가 service 파라미터를 지원한다면 검증
+    # 현재 구현에서는 로그 호출 시 service를 전달
+    client.log("INFO", "test", service="custom-service")
+    assert True
+
+
+def test_auto_caller_enabled():
+    """호출 위치 자동 추적 테스트 (auto_caller=True)"""
+    client = AsyncLogClient("http://localhost:8000", batch_size=100)
+
+    # 로그 호출
+    client.info("Test auto caller")
+
+    # 큐에서 로그 확인
+    assert len(client.queue) > 0
+    log_entry = client.queue[-1]
+
+    # function_name, file_path가 자동으로 포함되었는지 확인
+    assert "function_name" in log_entry
+    assert "file_path" in log_entry
+
+    # 함수명이 현재 테스트 함수명과 일치하는지 확인
+    assert log_entry["function_name"] == "test_auto_caller_enabled"
+
+    # 파일 경로에 test_async_client.py가 포함되는지 확인
+    assert "test_async_client.py" in log_entry["file_path"]
+
+
+def test_auto_caller_disabled():
+    """호출 위치 자동 추적 비활성화 테스트 (auto_caller=False)"""
+    client = AsyncLogClient("http://localhost:8000", batch_size=100)
+
+    # auto_caller=False로 로그 호출
+    client.log("INFO", "Test without auto caller", auto_caller=False)
+
+    # 큐에서 로그 확인
+    assert len(client.queue) > 0
+    log_entry = client.queue[-1]
+
+    # function_name이 자동으로 추가되지 않았는지 확인
+    # (수동으로 전달하지 않았으므로 없어야 함)
+    assert "function_name" not in log_entry or log_entry["function_name"] is None
+
+
+def test_auto_caller_manual_override():
+    """호출 위치 수동 재정의 테스트"""
+    client = AsyncLogClient("http://localhost:8000", batch_size=100)
+
+    # 수동으로 function_name 전달 (자동 추적보다 우선)
+    client.info("Test manual override", function_name="custom_function", file_path="/custom/path.py")
+
+    # 큐에서 로그 확인
+    assert len(client.queue) > 0
+    log_entry = client.queue[-1]
+
+    # 수동으로 전달한 값이 사용되었는지 확인
+    assert log_entry["function_name"] == "custom_function"
+    assert log_entry["file_path"] == "/custom/path.py"
+
+
+def test_convenience_methods_auto_caller():
+    """편의 메서드(info, debug 등)에서 호출 위치 자동 추적 테스트"""
+    client = AsyncLogClient("http://localhost:8000", batch_size=100)
+
+    # 여러 편의 메서드 테스트
+    client.trace("Trace message")
+    client.debug("Debug message")
+    client.info("Info message")
+    client.warn("Warn message")
+    client.error("Error message")
+    client.fatal("Fatal message")
+
+    # 모든 로그가 큐에 추가되었는지 확인
+    assert len(client.queue) == 6
+
+    # 각 로그에 function_name이 포함되었는지 확인
+    for log_entry in client.queue:
+        assert "function_name" in log_entry
+        # 모든 로그가 이 테스트 함수에서 호출되었으므로 함수명 일치
+        assert log_entry["function_name"] == "test_convenience_methods_auto_caller"
+
+
+def test_nested_function_auto_caller():
+    """중첩 함수에서 호출 위치 자동 추적 테스트"""
+    client = AsyncLogClient("http://localhost:8000", batch_size=100)
+
+    def inner_function():
+        client.info("Message from inner function")
+
+    # 내부 함수 호출
+    inner_function()
+
+    # 큐에서 로그 확인
+    assert len(client.queue) > 0
+    log_entry = client.queue[-1]
+
+    # function_name이 inner_function인지 확인
+    assert log_entry["function_name"] == "inner_function"
+
+
+# Feature 3: 사용자 컨텍스트 관리 테스트
+def test_user_context_enabled():
+    """사용자 컨텍스트 자동 포함 테스트"""
+    client = AsyncLogClient("http://localhost:8000", batch_size=100)
+
+    # 컨텍스트 없이 로그
+    client.info("Without context")
+    log_without_context = client.queue[-1]
+    assert "user_id" not in log_without_context
+    assert "trace_id" not in log_without_context
+
+    # 컨텍스트 있이 로그
+    with AsyncLogClient.user_context(user_id="user_123", trace_id="trace_xyz"):
+        client.info("With context")
+        log_with_context = client.queue[-1]
+
+        # user_id, trace_id가 자동으로 포함되었는지 확인
+        assert log_with_context["user_id"] == "user_123"
+        assert log_with_context["trace_id"] == "trace_xyz"
+        assert log_with_context["message"] == "With context"
+
+
+def test_user_context_clear():
+    """사용자 컨텍스트 초기화 테스트"""
+    client = AsyncLogClient("http://localhost:8000", batch_size=100)
+
+    # with 블록 내에서 컨텍스트 포함
+    with AsyncLogClient.user_context(user_id="user_456"):
+        client.info("Inside context")
+        assert client.queue[-1]["user_id"] == "user_456"
+
+    # with 블록 벗어나면 컨텍스트 자동 초기화
+    client.info("Outside context")
+    log_outside = client.queue[-1]
+    assert "user_id" not in log_outside
+
+
+def test_user_context_set_clear():
+    """set/clear 방식 사용자 컨텍스트 테스트"""
+    client = AsyncLogClient("http://localhost:8000", batch_size=100)
+
+    # 컨텍스트 설정
+    AsyncLogClient.set_user_context(user_id="user_789", session_id="sess_abc")
+
+    client.info("After set")
+    log_after_set = client.queue[-1]
+    assert log_after_set["user_id"] == "user_789"
+    assert log_after_set["session_id"] == "sess_abc"
+
+    # 컨텍스트 초기화
+    AsyncLogClient.clear_user_context()
+
+    client.info("After clear")
+    log_after_clear = client.queue[-1]
+    assert "user_id" not in log_after_clear
+    assert "session_id" not in log_after_clear
+
+
+def test_user_context_nested():
+    """중첩 사용자 컨텍스트 테스트"""
+    client = AsyncLogClient("http://localhost:8000", batch_size=100)
+
+    # 외부 컨텍스트: tenant_id
+    with AsyncLogClient.user_context(tenant_id="tenant_1"):
+        client.info("Outer context")
+        outer_log = client.queue[-1]
+        assert outer_log["tenant_id"] == "tenant_1"
+        assert "user_id" not in outer_log
+
+        # 내부 컨텍스트: user_id 추가
+        with AsyncLogClient.user_context(user_id="user_999"):
+            client.info("Inner context")
+            inner_log = client.queue[-1]
+            # tenant_id와 user_id 둘 다 포함되어야 함
+            assert inner_log["tenant_id"] == "tenant_1"
+            assert inner_log["user_id"] == "user_999"
+
+        # 내부 컨텍스트 벗어나면 user_id 없음
+        client.info("Back to outer")
+        back_to_outer = client.queue[-1]
+        assert back_to_outer["tenant_id"] == "tenant_1"
+        assert "user_id" not in back_to_outer
+
+
+def test_user_context_with_http_context():
+    """HTTP 컨텍스트와 사용자 컨텍스트 함께 사용 테스트"""
+    client = AsyncLogClient("http://localhost:8000", batch_size=100)
+
+    # HTTP 컨텍스트 설정
+    AsyncLogClient.set_request_context(path="/api/users", method="GET", ip="127.0.0.1")
+
+    # 사용자 컨텍스트 설정
+    with AsyncLogClient.user_context(user_id="user_combo", trace_id="trace_combo"):
+        client.info("Combined contexts")
+        log_entry = client.queue[-1]
+
+        # HTTP 컨텍스트 필드
+        assert log_entry["path"] == "/api/users"
+        assert log_entry["method"] == "GET"
+        assert log_entry["ip"] == "127.0.0.1"
+
+        # 사용자 컨텍스트 필드
+        assert log_entry["user_id"] == "user_combo"
+        assert log_entry["trace_id"] == "trace_combo"
+
+        # 기본 필드
+        assert log_entry["message"] == "Combined contexts"
+
+    # 정리
+    AsyncLogClient.clear_request_context()
+
+
+def test_user_context_manual_override():
+    """사용자 컨텍스트보다 수동 값이 우선하는지 테스트"""
+    client = AsyncLogClient("http://localhost:8000", batch_size=100)
+
+    with AsyncLogClient.user_context(user_id="auto_user"):
+        # 수동으로 user_id 전달
+        client.info("Manual override", user_id="manual_user")
+        log_entry = client.queue[-1]
+
+        # 수동 값이 우선해야 함
+        assert log_entry["user_id"] == "manual_user"

tests/test_integration.py

@@ -0,0 +1,372 @@
+"""
+통합 테스트: 로그 서버와의 E2E 검증
+실행 전 요구사항:
+1. PostgreSQL 실행 (localhost:5432)
+2. 로그 서버 실행 (localhost:8000)
+3. 스키마 생성 완료
+"""
+import pytest
+import time
+import requests
+from log_collector import AsyncLogClient
+
+
+@pytest.fixture
+def log_server_url():
+    """로그 서버 URL (서버 실행 필요)"""
+    return "http://localhost:8000"
+
+
+@pytest.fixture
+def check_server_running(log_server_url):
+    """로그 서버 실행 여부 확인"""
+    try:
+        response = requests.get(log_server_url, timeout=1)
+        if response.status_code != 200:
+            pytest.skip("로그 서버가 실행되지 않았습니다")
+    except requests.exceptions.RequestException:
+        pytest.skip("로그 서버가 실행되지 않았습니다")
+
+
+def test_end_to_end_logging(log_server_url, check_server_running):
+    """E2E: 로그 전송 → 서버 수신 → DB 저장"""
+    client = AsyncLogClient(log_server_url, batch_size=5, flush_interval=1.0)
+
+    # 5개 로그 전송
+    for i in range(5):
+        client.log("INFO", f"Integration test {i}", test_id="e2e_test", iteration=i)
+
+    # Flush 대기
+    time.sleep(2)
+
+    # 서버 통계 확인
+    response = requests.get(f"{log_server_url}/stats")
+    assert response.status_code == 200
+
+    stats = response.json()
+    assert stats['total_logs'] >= 5, f"Expected >= 5 logs, got {stats['total_logs']}"
+
+
+def test_batch_sending(log_server_url, check_server_running):
+    """배치 전송 테스트: 10개 로그 → 자동 배치 전송"""
+    client = AsyncLogClient(log_server_url, batch_size=10)
+
+    # 10개 로그 → 자동 배치 전송
+    for i in range(10):
+        client.log("INFO", f"Batch test {i}", test_id="batch_test", iteration=i)
+
+    # 배치 전송 대기
+    time.sleep(1.5)
+
+    # 서버 통계 확인
+    response = requests.get(f"{log_server_url}/stats")
+    assert response.status_code == 200
+
+    stats = response.json()
+    assert stats['total_logs'] >= 10
+
+
+def test_flush_interval(log_server_url, check_server_running):
+    """Flush 간격 테스트: 1초 후 자동 전송"""
+    client = AsyncLogClient(log_server_url, batch_size=1000, flush_interval=1.0)
+
+    # 5개만 보내기 (배치 크기 미달)
+    for i in range(5):
+        client.log("INFO", f"Flush interval test {i}", test_id="flush_test")
+
+    # 1초 대기 → flush_interval에 의해 자동 전송되어야 함
+    time.sleep(1.5)
+
+    # 서버 통계 확인
+    response = requests.get(f"{log_server_url}/stats")
+    assert response.status_code == 200
+
+
+def test_manual_flush(log_server_url, check_server_running):
+    """수동 flush 테스트"""
+    client = AsyncLogClient(log_server_url, batch_size=1000, flush_interval=60)
+
+    # 3개 로그 (배치 크기 미달, flush_interval도 길음)
+    for i in range(3):
+        client.log("INFO", f"Manual flush test {i}", test_id="manual_flush_test")
+
+    # 수동 flush 호출
+    client.flush()
+
+    # 약간의 대기
+    time.sleep(0.5)
+
+    # 서버 통계 확인
+    response = requests.get(f"{log_server_url}/stats")
+    assert response.status_code == 200
+
+
+def test_multiple_services(log_server_url, check_server_running):
+    """여러 서비스의 로그 동시 전송"""
+    services = ["auth-service", "api-service", "db-service", "cache-service"]
+
+    client = AsyncLogClient(log_server_url, batch_size=20)
+
+    # 각 서비스에서 5개씩 로그 전송
+    for service in services:
+        for i in range(5):
+            client.log(
+                "INFO",
+                f"Log from {service} #{i}",
+                service=service,
+                test_id="multi_service_test"
+            )
+
+    # 배치 전송 대기
+    time.sleep(2)
+
+    # 서버 통계 확인
+    response = requests.get(f"{log_server_url}/stats")
+    assert response.status_code == 200
+    stats = response.json()
+    assert stats['total_logs'] >= 20
+
+
+def test_error_logging(log_server_url, check_server_running):
+    """에러 로그 전송 테스트"""
+    client = AsyncLogClient(log_server_url, batch_size=5)
+
+    # 에러 로그 전송
+    for i in range(5):
+        client.log(
+            "ERROR",
+            f"Database connection failed: attempt {i}",
+            error_code="DB_CONN_ERR",
+            service="db-service",
+            test_id="error_test"
+        )
+
+    time.sleep(1.5)
+
+    # 서버 통계 확인
+    response = requests.get(f"{log_server_url}/stats")
+    assert response.status_code == 200
+
+    stats = response.json()
+    # 레벨별 분포에 ERROR가 있어야 함
+    assert 'level_distribution' in stats
+    assert any(item['level'] == 'ERROR' for item in stats['level_distribution'])
+
+
+def test_auto_caller_integration(log_server_url, check_server_running):
+    """호출 위치 자동 추적 통합 테스트 (E2E)"""
+    client = AsyncLogClient(log_server_url, batch_size=5, flush_interval=1.0)
+
+    # auto_caller 활성화된 상태로 로그 전송
+    client.info("Auto caller test - line 1", test_id="auto_caller_integration")
+    client.debug("Auto caller test - line 2", test_id="auto_caller_integration")
+    client.warn("Auto caller test - line 3", test_id="auto_caller_integration")
+
+    # 편의 메서드를 통한 로그도 테스트
+    def helper_function():
+        client.info("Message from helper function", test_id="auto_caller_integration")
+
+    helper_function()
+
+    # Flush 대기
+    time.sleep(2)
+
+    # 서버 통계 확인 (에러 없이 전송되었는지)
+    response = requests.get(f"{log_server_url}/stats")
+    assert response.status_code == 200
+
+    stats = response.json()
+    assert stats['total_logs'] >= 4
+
+    # Note: function_name, file_path가 실제로 DB에 저장되었는지는
+    # PostgreSQL 직접 쿼리로 확인 필요:
+    # SELECT function_name, file_path, message
+    # FROM logs
+    # WHERE metadata->>'test_id' = 'auto_caller_integration';
+
+
+def test_auto_caller_disabled_integration(log_server_url, check_server_running):
+    """호출 위치 자동 추적 비활성화 통합 테스트"""
+    client = AsyncLogClient(log_server_url, batch_size=5, flush_interval=1.0)
+
+    # auto_caller=False로 로그 전송
+    client.log(
+        "INFO",
+        "Auto caller disabled test",
+        auto_caller=False,
+        test_id="auto_caller_disabled"
+    )
+
+    # Flush 대기
+    time.sleep(2)
+
+    # 서버 통계 확인 (에러 없이 전송되었는지)
+    response = requests.get(f"{log_server_url}/stats")
+    assert response.status_code == 200
+
+
+def test_timer_with_auto_caller(log_server_url, check_server_running):
+    """타이머 기능과 auto_caller 통합 테스트"""
+    client = AsyncLogClient(log_server_url, batch_size=5, flush_interval=1.0)
+
+    # 타이머 사용 시에도 auto_caller가 동작해야 함
+    timer = client.start_timer()
+    time.sleep(0.1)  # 작업 시뮬레이션
+    client.end_timer(timer, "INFO", "Timer test completed", test_id="timer_auto_caller")
+
+    # 컨텍스트 매니저 타이머
+    with client.timer("Context manager timer test"):
+        time.sleep(0.05)
+
+    # Flush 대기
+    time.sleep(2)
+
+    # 서버 통계 확인
+    response = requests.get(f"{log_server_url}/stats")
+    assert response.status_code == 200
+
+
+def test_error_with_trace_integration(log_server_url, check_server_running):
+    """error_with_trace와 auto_caller 통합 테스트"""
+    client = AsyncLogClient(log_server_url, batch_size=5, flush_interval=1.0)
+
+    # 예외 발생 시뮬레이션
+    try:
+        raise ValueError("Test exception for integration test")
+    except Exception as e:
+        client.error_with_trace(
+            "Integration test exception",
+            exception=e,
+            test_id="error_trace_integration"
+        )
+
+    # Flush 대기
+    time.sleep(2)
+
+    # 서버 통계 확인
+    response = requests.get(f"{log_server_url}/stats")
+    assert response.status_code == 200
+
+    # Note: stack_trace, error_type, function_name, file_path가 DB에 저장되었는지는
+    # PostgreSQL 직접 쿼리로 확인:
+    # SELECT stack_trace, error_type, function_name, file_path
+    # FROM logs
+    # WHERE metadata->>'test_id' = 'error_trace_integration';
+
+
+# Feature 3: 사용자 컨텍스트 관리 통합 테스트
+def test_user_context_integration(log_server_url, check_server_running):
+    """사용자 컨텍스트 자동 포함 통합 테스트 (E2E)"""
+    client = AsyncLogClient(log_server_url, batch_size=10, flush_interval=1.0)
+
+    # 컨텍스트 없이 로그
+    client.info("Without user context", test_id="user_context_integration")
+
+    # 컨텍스트 있이 로그
+    with AsyncLogClient.user_context(
+        user_id="integration_user_123",
+        trace_id="integration_trace_xyz"
+    ):
+        client.info("With user context 1", test_id="user_context_integration")
+        client.info("With user context 2", test_id="user_context_integration")
+        client.warn("User context warning", test_id="user_context_integration")
+
+    # 컨텍스트 밖에서 다시 로그
+    client.info("After user context", test_id="user_context_integration")
+
+    # Flush 대기
+    time.sleep(2)
+
+    # 서버 통계 확인 (에러 없이 전송되었는지)
+    response = requests.get(f"{log_server_url}/stats")
+    assert response.status_code == 200
+
+    stats = response.json()
+    assert stats['total_logs'] >= 5
+
+    # Note: user_id, trace_id가 실제로 DB에 저장되었는지는
+    # PostgreSQL 직접 쿼리로 확인 필요:
+    # SELECT
+    #   message,
+    #   metadata->>'user_id' as user_id,
+    #   metadata->>'trace_id' as trace_id
+    # FROM logs
+    # WHERE metadata->>'test_id' = 'user_context_integration'
+    # ORDER BY created_at;
+
+
+def test_user_context_with_http_context_integration(log_server_url, check_server_running):
+    """HTTP 컨텍스트와 사용자 컨텍스트 함께 사용 통합 테스트"""
+    client = AsyncLogClient(log_server_url, batch_size=10, flush_interval=1.0)
+
+    # HTTP 컨텍스트 설정
+    AsyncLogClient.set_request_context(
+        path="/api/test",
+        method="POST",
+        ip="192.168.1.100"
+    )
+
+    # 사용자 컨텍스트와 함께 사용
+    with AsyncLogClient.user_context(
+        user_id="combined_user_456",
+        trace_id="combined_trace_abc",
+        session_id="combined_session_xyz"
+    ):
+        client.info("Combined contexts test 1", test_id="combined_contexts_integration")
+        client.debug("Combined contexts test 2", test_id="combined_contexts_integration")
+
+    # 정리
+    AsyncLogClient.clear_request_context()
+
+    # Flush 대기
+    time.sleep(2)
+
+    # 서버 통계 확인
+    response = requests.get(f"{log_server_url}/stats")
+    assert response.status_code == 200
+
+    stats = response.json()
+    assert stats['total_logs'] >= 2
+
+    # Note: HTTP와 User 컨텍스트가 모두 DB에 저장되었는지 확인:
+    # SELECT
+    #   message,
+    #   metadata->>'path' as path,
+    #   metadata->>'method' as method,
+    #   metadata->>'ip' as ip,
+    #   metadata->>'user_id' as user_id,
+    #   metadata->>'trace_id' as trace_id,
+    #   metadata->>'session_id' as session_id
+    # FROM logs
+    # WHERE metadata->>'test_id' = 'combined_contexts_integration';
+
+
+def test_user_context_nested_integration(log_server_url, check_server_running):
+    """중첩 사용자 컨텍스트 통합 테스트"""
+    client = AsyncLogClient(log_server_url, batch_size=10, flush_interval=1.0)
+
+    # 외부 컨텍스트
+    with AsyncLogClient.user_context(tenant_id="tenant_integration"):
+        client.info("Outer context", test_id="nested_user_context_integration")
+
+        # 내부 컨텍스트
+        with AsyncLogClient.user_context(user_id="nested_user_789"):
+            client.info("Inner context (both)", test_id="nested_user_context_integration")
+
+        client.info("Back to outer", test_id="nested_user_context_integration")
+
+    # Flush 대기
+    time.sleep(2)
+
+    # 서버 통계 확인
+    response = requests.get(f"{log_server_url}/stats")
+    assert response.status_code == 200
+
+    # Note: 중첩 컨텍스트가 올바르게 저장되었는지 확인:
+    # SELECT
+    #   message,
+    #   metadata->>'tenant_id' as tenant_id,
+    #   metadata->>'user_id' as user_id
+    # FROM logs
+    # WHERE metadata->>'test_id' = 'nested_user_context_integration'
+    # ORDER BY created_at;