Polling

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

// 효율적인 폴링 엔드포인트 예시 (Spring Boot)
@RestController
@RequestMapping("/api/polls")
public class PollingController {

    private final PollingService pollingService;
    
    @GetMapping("/status")
    public ResponseEntity<StatusResponse> getStatus(
            @RequestParam(required = false) String lastKnownVersion) {
        
        // 현재 상태 버전 조회
        String currentVersion = pollingService.getCurrentVersion();
        
        // 변경 사항이 없으면 304 Not Modified 반환
        if (currentVersion.equals(lastKnownVersion)) {
            return ResponseEntity
                .status(HttpStatus.NOT_MODIFIED)
                .build();
        }
        
        // 변경 사항이 있으면 새 데이터 제공
        StatusResponse status = pollingService.getStatus();
        
        return ResponseEntity.ok()
            .eTag(currentVersion)  // ETag 헤더 설정
            .cacheControl(CacheControl.noCache())  // 캐싱 제어
            .body(status);
    }
    
    @GetMapping("/events")
    public ResponseEntity<List<Event>> getEvents(
            @RequestParam(required = false) Long afterTimestamp,
            @RequestParam(defaultValue = "100") int limit) {
        
        Long lastEventTimestamp;
        List<Event> events;
        
        if (afterTimestamp != null) {
            // 지정된 타임스탬프 이후의 이벤트만 조회
            events = pollingService.getEventsAfter(afterTimestamp, limit);
            
            // 결과가 없으면 204 No Content 반환
            if (events.isEmpty()) {
                return ResponseEntity
                    .noContent()
                    .build();
            }
        } else {
            // 최신 이벤트 조회
            events = pollingService.getLatestEvents(limit);
        }
        
        // 마지막 이벤트 타임스탬프 계산
        lastEventTimestamp = events.isEmpty() ? 
            System.currentTimeMillis() : 
            events.get(events.size() - 1).getTimestamp();
        
        return ResponseEntity.ok()
            .header("X-Last-Event-Timestamp", lastEventTimestamp.toString())
            .body(events);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

// 변경 사항 감지 메커니즘 예시 (Spring Boot)
@Service
public class PollingServiceImpl implements PollingService {

    private final DataRepository dataRepository;
    private final VersionManager versionManager;
    
    // 버전 기반 변경 감지
    @Override
    public String getCurrentVersion() {
        return versionManager.getCurrentVersion();
    }
    
    @Override
    public StatusResponse getStatus() {
        StatusData data = dataRepository.getCurrentData();
        
        return new StatusResponse(
            data,
            versionManager.getCurrentVersion(),
            System.currentTimeMillis()
        );
    }
    
    // 타임스탬프 기반 변경 감지
    @Override
    public List<Event> getEventsAfter(Long timestamp, int limit) {
        return dataRepository.findEventsByTimestampAfter(timestamp, limit);
    }
    
    @Override
    public List<Event> getLatestEvents(int limit) {
        return dataRepository.findLatestEvents(limit);
    }
    
    // 데이터 변경 시 버전 업데이트
    @EventListener
    public void handleDataChangeEvent(DataChangeEvent event) {
        versionManager.incrementVersion();
    }
}

// 버전 관리 서비스
@Service
public class VersionManager {
    
    private AtomicLong version = new AtomicLong(0);
    
    public String getCurrentVersion() {
        return "v" + version.get();
    }
    
    public void incrementVersion() {
        version.incrementAndGet();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

// 롱 폴링 구현 예시 (Spring Boot + DeferredResult)
@RestController
@RequestMapping("/api/polls")
public class LongPollingController {

    private final EventService eventService;
    private final ConcurrentMap<String, DeferredResult<ResponseEntity<List<Event>>>> activeRequests = new ConcurrentHashMap<>();
    
    @GetMapping("/events/longpoll")
    public DeferredResult<ResponseEntity<List<Event>>> longPollEvents(
            @RequestParam(required = false) Long afterTimestamp,
            @RequestParam(defaultValue = "30000") long timeout) {
        
        // DeferredResult 생성 (타임아웃 설정)
        DeferredResult<ResponseEntity<List<Event>>> result = new DeferredResult<>(timeout);
        
        // 타임아웃 처리
        result.onTimeout(() -> {
            List<Event> events = eventService.getLatestEvents(10);
            Long lastTimestamp = events.isEmpty() ? 
                System.currentTimeMillis() : 
                events.get(events.size() - 1).getTimestamp();
                
            result.setResult(ResponseEntity.ok()
                .header("X-Last-Event-Timestamp", lastTimestamp.toString())
                .body(events));
        });
        
        // 요청 완료 시 정리
        result.onCompletion(() -> {
            activeRequests.remove(result.toString());
        });
        
        // 현재 이벤트 확인
        if (afterTimestamp != null) {
            List<Event> newEvents = eventService.getEventsAfter(afterTimestamp, 10);
            
            if (!newEvents.isEmpty()) {
                // 이미 새 이벤트가 있으면 즉시 응답
                Long lastTimestamp = newEvents.get(newEvents.size() - 1).getTimestamp();
                
                result.setResult(ResponseEntity.ok()
                    .header("X-Last-Event-Timestamp", lastTimestamp.toString())
                    .body(newEvents));
                    
                return result;
            }
        }
        
        // 요청 등록 (새 이벤트 발생 시 알림 받기 위함)
        String requestId = UUID.randomUUID().toString();
        activeRequests.put(requestId, result);
        
        return result;
    }
    
    // 새 이벤트 발생 시 대기 중인 요청에 알림
    @EventListener
    public void handleEventCreated(EventCreatedEvent createdEvent) {
        Event event = createdEvent.getEvent();
        
        List<Event> events = Collections.singletonList(event);
        
        // 모든 대기 중인 롱 폴링 요청에 응답
        activeRequests.forEach((requestId, deferredResult) -> {
            if (!deferredResult.isSetOrExpired()) {
                deferredResult.setResult(ResponseEntity.ok()
                    .header("X-Last-Event-Timestamp", event.getTimestamp().toString())
                    .body(events));
            }
        });
        
        // 응답한 요청은 맵에서 제거 (이미 onCompletion에서 처리됨)
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// 조건부 요청 처리 예시 (Spring Boot)
@GetMapping("/data")
public ResponseEntity<DataResponse> getData(
        @RequestHeader(value = "If-None-Match", required = false) String ifNoneMatch) {
    
    // 현재 데이터 버전 확인
    String currentETag = dataService.getCurrentETag();
    
    // ETag가 일치하면 304 Not Modified 반환
    if (currentETag.equals(ifNoneMatch)) {
        return ResponseEntity
            .status(HttpStatus.NOT_MODIFIED)
            .eTag(currentETag)
            .build();
    }
    
    // 변경된 데이터 조회
    DataResponse data = dataService.getCurrentData();
    
    // 200 OK와 함께 데이터 및 ETag 반환
    return ResponseEntity.ok()
        .eTag(currentETag)
        .body(data);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// 부분 응답 구현 예시 (Spring Boot)
@GetMapping("/data/delta")
public ResponseEntity<DataDelta> getDataDelta(
        @RequestParam String baseVersion) {
    
    // 기준 버전에서의 변경 사항 계산
    DataDelta delta = dataService.computeDeltaSince(baseVersion);
    
    // 변경 사항이 없으면 204 No Content 반환
    if (delta.isEmpty()) {
        return ResponseEntity
            .noContent()
            .header("X-Current-Version", dataService.getCurrentVersion())
            .build();
    }
    
    // 변경 내용 반환
    return ResponseEntity.ok()
        .header("X-Current-Version", dataService.getCurrentVersion())
        .body(delta);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// 페이지네이션 및 필터링 예시 (Spring Boot)
@GetMapping("/events")
public ResponseEntity<Page<Event>> getEvents(
        @RequestParam(defaultValue = "0") int page,
        @RequestParam(defaultValue = "50") int size,
        @RequestParam(required = false) Long afterTimestamp,
        @RequestParam(required = false) String type) {
    
    // 페이지네이션 및 필터링 정보
    Pageable pageable = PageRequest.of(page, size, Sort.by("timestamp").descending());
    
    // 필터 적용된 데이터 조회
    Page<Event> events;
    if (afterTimestamp != null && type != null) {
        events = eventRepository.findByTimestampAfterAndType(afterTimestamp, type, pageable);
    } else if (afterTimestamp != null) {
        events = eventRepository.findByTimestampAfter(afterTimestamp, pageable);
    } else if (type != null) {
        events = eventRepository.findByType(type, pageable);
    } else {
        events = eventRepository.findAll(pageable);
    }
    
    return ResponseEntity.ok(events);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

// 지수 백오프 구현 예시 (JavaScript)
function pollWithExponentialBackoff() {
  let retryCount = 0;
  const MAX_RETRIES = 10;
  const BASE_DELAY = 1000;
  const MAX_DELAY = 60000;
  
  function poll() {
    fetch('/api/status')
      .then(response => {
        if (!response.ok) {
          throw new Error(`HTTP error ${response.status}`);
        }
        return response.json();
      })
      .then(data => {
        // 성공적인 응답, 재시도 카운트 초기화
        retryCount = 0;
        console.log('폴링 데이터:', data);
        
        // 정상 간격으로 다음 폴링 예약
        setTimeout(poll, BASE_DELAY);
      })
      .catch(error => {
        console.error('폴링 오류:', error);
        
        // 최대 재시도 횟수 확인
        if (retryCount >= MAX_RETRIES) {
          console.error('최대 재시도 횟수 초과, 폴링 중단');
          return;
        }
        
        // 지수 백오프 계산
        retryCount++;
        const delay = Math.min(MAX_DELAY, BASE_DELAY * Math.pow(2, retryCount));
        console.log(`${delay}ms 후 재시도 (${retryCount}/${MAX_RETRIES})`);
        
        // 계산된 지연 후 다시 시도
        setTimeout(poll, delay);
      });
  }
  
  // 첫 번째 폴링 시작
  poll();
}

pollWithExponentialBackoff();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

// 사용자 활동 기반 폴링 예시 (JavaScript)
function userActivityBasedPolling() {
  const ACTIVE_POLLING_INTERVAL = 5000;    // 활성 상태일 때 5초
  const INACTIVE_POLLING_INTERVAL = 30000; // 비활성 상태일 때 30초
  
  let isUserActive = true;
  let pollingInterval = ACTIVE_POLLING_INTERVAL;
  let inactivityTimeout;
  let pollingTimeout;
  
  // 사용자 활동 감지
  function resetInactivityTimer() {
    // 기존 타이머 취소
    if (inactivityTimeout) {
      clearTimeout(inactivityTimeout);
    }
    
    // 사용자가 비활성 상태였다면 활성 상태로 변경
    if (!isUserActive) {
      isUserActive = true;
      pollingInterval = ACTIVE_POLLING_INTERVAL;
      
      // 빠른 폴링으로 즉시 전환
      if (pollingTimeout) {
        clearTimeout(pollingTimeout);
        poll();
      }
    }
    
    // 비활성 타이머 설정
    inactivityTimeout = setTimeout(() => {
      isUserActive = false;
      pollingInterval = INACTIVE_POLLING_INTERVAL;
    }, 60000); // 1분 동안 활동 없으면 비활성으로 간주
  }
  
  // 사용자 활동 이벤트 리스너
  document.addEventListener('mousemove', resetInactivityTimer);
  document.addEventListener('keydown', resetInactivityTimer);
  document.addEventListener('click', resetInactivityTimer);
  
  // 페이지 가시성 변경 처리
  document.addEventListener('visibilitychange', () => {
    if (document.hidden) {
      // 페이지가 숨겨지면 비활성으로 간주
      isUserActive = false;
      pollingInterval = INACTIVE_POLLING_INTERVAL;
    } else {
      // 페이지가 다시 보이면 활성으로 간주
      isUserActive = true;
      pollingInterval = ACTIVE_POLLING_INTERVAL;
      
      // 빠른 폴링으로 즉시 전환
      if (pollingTimeout) {
        clearTimeout(pollingTimeout);
        poll();
      }
    }
  });
  
  // 폴링 함수
  function poll() {
    fetch('/api/status')
      .then(response => response.json())
      .then(data => {
        console.log('폴링 데이터:', data);
        
        // 현재 활동 상태에 따른 간격으로 다음 폴링 예약
        pollingTimeout = setTimeout(poll, pollingInterval);
      })
      .catch(error => {
        console.error('폴링 오류:', error);
        
        // 오류 시에도 다음 폴링 예약
        pollingTimeout = setTimeout(poll, pollingInterval);
      });
  }
  
  // 초기 비활성 타이머 설정
  resetInactivityTimer();
  
  // 첫 번째 폴링 시작
  poll();
  
  // 클린업 함수
  return function cleanup() {
    if (pollingTimeout) {
      clearTimeout(pollingTimeout);
    }
    if (inactivityTimeout) {
      clearTimeout(inactivityTimeout);
    }
    document.removeEventListener('mousemove', resetInactivityTimer);
    document.removeEventListener('keydown', resetInactivityTimer);
    document.removeEventListener('click', resetInactivityTimer);
  };
}

const cleanup = userActivityBasedPolling();

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

// 네트워크 상태 감지 기반 폴링 예시 (JavaScript)
function networkAwarePolling() {
  const NORMAL_POLLING_INTERVAL = 5000;   // 정상 연결 시 5초
  const SLOW_POLLING_INTERVAL = 15000;    // 느린 연결 시 15초
  const OFFLINE_RETRY_INTERVAL = 30000;   // 오프라인 시 30초
  
  let pollingInterval = NORMAL_POLLING_INTERVAL;
  let isOnline = navigator.onLine;
  let connectionType = 'unknown';
  let pollingTimeout;
  
  // 연결 유형 감지 (Network Information API 사용)
  if ('connection' in navigator) {
    connectionType = navigator.connection.effectiveType;
    
    // 연결 상태 변화 감지
    navigator.connection.addEventListener('change', updateConnectionStatus);
  }
  
  // 온라인/오프라인 상태 감지
  window.addEventListener('online', () => {
    isOnline = true;
    updatePollingInterval();
    
    // 연결 복구 시 즉시 폴링
    if (pollingTimeout) {
      clearTimeout(pollingTimeout);
      poll();
    }
  });
  
  window.addEventListener('offline', () => {
    isOnline = false;
    updatePollingInterval();
  });
  
  function updateConnectionStatus() {
    if (navigator.connection) {
      connectionType = navigator.connection.effectiveType;
      updatePollingInterval();
    }
  }
  
  function updatePollingInterval() {
    if (!isOnline) {
      pollingInterval = OFFLINE_RETRY_INTERVAL;
      console.log('오프라인 상태, 폴링 간격:', pollingInterval);
      return;
    }
    
    // 연결 유형에 따른 간격 설정
    switch (connectionType) {
      case 'slow-2g':
      case '2g':
        pollingInterval = SLOW_POLLING_INTERVAL;
        break;
      case '3g':
        pollingInterval = NORMAL_POLLING_INTERVAL;
        break;
      case '4g':
        pollingInterval = NORMAL_POLLING_INTERVAL;
        break;
      default:
        pollingInterval = NORMAL_POLLING_INTERVAL;
    }
    
    console.log(`네트워크 상태: ${connectionType}, 폴링 간격: ${pollingInterval}ms`);
  }
  
  function poll() {
    if (!isOnline) {
      console.log('오프라인 상태, 다음 폴링 예약');
      pollingTimeout = setTimeout(poll, pollingInterval);
      return;
    }
    
    const startTime = Date.now();
    
    fetch('/api/status')
      .then(response => response.json())
      .then(data => {
        console.log('폴링 데이터:', data);
        
        // 응답 시간 측정
        const responseTime = Date.now() - startTime;
        
        // 응답 시간에 따른 연결 품질 추정
        if (responseTime > 1000) {
          // 응답이 느리면 폴링 간격 증가
          pollingInterval = Math.min(pollingInterval * 1.5, SLOW_POLLING_INTERVAL);
        } else {
          // 응답이 빠르면 폴링 간격 감소
          pollingInterval = Math.max(pollingInterval * 0.8, NORMAL_POLLING_INTERVAL);
        }
        
        // 다음 폴링 예약
        pollingTimeout = setTimeout(poll, pollingInterval);
      })
      .catch(error => {
        console.error('폴링 오류:', error);
        
        // 오류 시 폴링 간격 증가
        pollingInterval = Math.min(pollingInterval * 2, OFFLINE_RETRY_INTERVAL);
        
        // 다음 폴링 예약
        pollingTimeout = setTimeout(poll, pollingInterval);
      });
  }
  
  // 초기 폴링 간격 설정
  updatePollingInterval();
  
  // 첫 번째 폴링 시작
  poll();
  
  // 클린업 함수
  return function cleanup() {
    if (pollingTimeout) {
      clearTimeout(pollingTimeout);
    }
    window.removeEventListener('online', updatePollingInterval);
    window.removeEventListener('offline', updatePollingInterval);
    if ('connection' in navigator) {
      navigator.connection.removeEventListener('change', updateConnectionStatus);
    }
  };
}

const cleanup = networkAwarePolling();

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183

// 폴링과 웹훅 결합 예시 (JavaScript)
function hybridPollingWithWebhook() {
  const FALLBACK_POLLING_INTERVAL = 30000; // 폴백 폴링 간격: 30초
  
  let lastEventId = null;
  let pollingTimeout = null;
  let webhookConnected = false;
  
  // 웹훅 설정 (가능할 경우)
  async function setupWebhook() {
    try {
      // 웹훅 연결 요청
      const response = await fetch('/api/webhooks/register', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          callbackUrl: generateCallbackUrl(),
          events: ['data_updated', 'status_changed']
        })
      });
      
      if (response.ok) {
        const data = await response.json();
        console.log('웹훅 등록 성공:', data);
        webhookConnected = true;
        
        // 웹훅 연결 확인을 위한 주기적 확인
        startWebhookHeartbeat();
      } else {
        console.warn('웹훅 등록 실패, 폴링 사용');
        webhookConnected = false;
        startPolling();
      }
    } catch (error) {
      console.error('웹훅 설정 오류:', error);
      webhookConnected = false;
      startPolling();
    }
  }
  
  // 웹훅 콜백 URL 생성
  function generateCallbackUrl() {
    // 실제 구현에서는 서버나 서비스 워커로 웹훅을 수신할 적절한 URL 사용
    return 'https://webhook.example.com/callbacks/' + generateUniqueId();
  }
  
  // 고유 ID 생성
  function generateUniqueId() {
    return Date.now().toString(36) + Math.random().toString(36).substr(2, 5);
  }
  
  // 웹훅 연결 상태 확인
  function startWebhookHeartbeat() {
    setInterval(async () => {
      try {
        const response = await fetch('/api/webhooks/status');
        const data = await response.json();
        
        if (!data.connected) {
          console.warn('웹훅 연결 끊김, 폴링으로 전환');
          webhookConnected = false;
          startPolling();
        }
      } catch (error) {
        console.error('웹훅 상태 확인 오류:', error);
        webhookConnected = false;
        startPolling();
      }
    }, 60000); // 1분마다 확인
  }
  
  // 폴링 시작
  function startPolling() {
    if (pollingTimeout) return; // 이미 폴링 중인 경우
    
    poll();
  }
  
  // 폴링 중지
  function stopPolling() {
    if (pollingTimeout) {
      clearTimeout(pollingTimeout);
      pollingTimeout = null;
    }
  }
  
  // 폴링 함수
  async function poll() {
    try {
      // 마지막 이벤트 ID가 있으면 그 이후의 이벤트만 요청
      const url = lastEventId 
        ? `/api/events?afterId=${lastEventId}`
        : '/api/events';
      
      const response = await fetch(url);
      const events = await response.json();
      
      if (events.length > 0) {
        // 이벤트 처리
        processEvents(events);
        
        // 마지막 이벤트 ID 업데이트
        lastEventId = events[events.length - 1].id;
      }
      
      // 웹훅이 연결되어 있지 않은 경우에만 계속 폴링
      if (!webhookConnected) {
        pollingTimeout = setTimeout(poll, FALLBACK_POLLING_INTERVAL);
      } else {
        stopPolling();
      }
    } catch (error) {
      console.error('폴링 오류:', error);
      
      // 오류 시에도 계속 폴링
      pollingTimeout = setTimeout(poll, FALLBACK_POLLING_INTERVAL);
    }
  }
  
  // 이벤트 처리
  function processEvents(events) {
    for (const event of events) {
      console.log('이벤트 처리:', event);
      // 이벤트 유형에 따른 처리
      switch (event.type) {
        case 'data_updated':
          updateData(event.data);
          break;
        case 'status_changed':
          updateStatus(event.data);
          break;
        default:
          console.log('알 수 없는 이벤트 유형:', event.type);
      }
    }
  }
  
  // 데이터 업데이트 처리
  function updateData(data) {
    console.log('데이터 업데이트:', data);
    // 데이터 업데이트 로직
  }
  
  // 상태 변경 처리
  function updateStatus(status) {
    console.log('상태 변경:', status);
    // 상태 변경 로직
  }
  
  // 웹훅 콜백 처리 (실제 구현에서는 서버나 서비스 워커에서 처리)
  function handleWebhookCallback(eventData) {
    console.log('웹훅 콜백 수신:', eventData);
    
    // 이벤트 처리
    processEvents([eventData]);
    
    // 이벤트 ID 업데이트
    if (eventData.id) {
      lastEventId = eventData.id;
    }
  }
  
  // 초기화
  setupWebhook();
  
  // API 노출
  return {
    refresh: poll,
    setWebhookStatus: (connected) => {
      webhookConnected = connected;
      if (!connected) {
        startPolling();
      } else {
        stopPolling();
      }
    },
    handleWebhookCallback
  };
}

const hybridClient = hybridPollingWithWebhook();