[원문 출처] http://activemq.apache.org/slow-consumer-handling.html


해당 문서의 경우 Apache 재단의 ActiveMQ Document 문서 일부를 번역 한 것입니다. 
번역본인 해당 문서의 경우 역자에게 있음을 알리며 상업적 이용을 불허합니다. 

www.sogomsoft.co.kr (주) 소곰소프트



속도가 느린 컨슈머는 일단 채워진 RAM에 오래된 메시지를 유지하기 위해 프로듀서에 속도를 늦추도록 브로커에 강제할 수 있고 빠른 컨슈머가 속도가 느려지게 되기 때문에 비영속성 토픽에서 문제가 발생 할 수 있다. 이후에 우리가 구현 할수 있는 하나의 옵션은 디스크에 스플링(디스크에 쓰기와 동시에 처리) 하는 것이다.  그러나 디스크에 스플링 하는 것 역시 속도가 빠른 컨슈머를 속도를 감소 시킨다.

현재 브로커의 프리패치 버퍼에 추가된 컨슈머를 위해 브로커가 유지하게 되는 일치하는 메시지의 최대 수를 환경 구성하는 전략을 가지고 있다. 최대 값에 도달 할 때, 새 메시지가 들어 오기 때문에 오래된 메시지들은 폐기 된다. 이것은 현재 메시지를 위해 RAM을  유지하고 속도가 느린 컨슈머에 메시지를 보내는 것을 유지하는 것을 허용한다. 그러나 오래된 메시지는 폐기한다.

지연 메시지 제한 전략(Pending Message Limit Strategy)

목적지 Map에 PendingMessageLimitStrategy 구현체 클래스를 환경 구성할 수 있다. 그래서 토픽 네임스페이스의 다른 영역이 속도가 늦은 컨슈머를 다루기 위한 다른 지연 전략을 가질 수 있다. 예를 들면,  매우 부피가 큰가격을 위해 지연 전략을 사용하기를 원할지 모른다. 그러나 매우 작은 부피를 가지는 주문과 거래를 위해 오래된 메시지는 폐기하는 것을 원하지 않을지 모른다.

이 전략은 컨슈머를 위해 RAM에 유지 되어야 하는 지연되는 메시지의 최대 량을 계산한다. (위 프리패치 사이즈). 0 값은 프리패치 량보다 더 이상의 메시지를 유지 하지 않는 다는 것을 의미한다. 0보다 큰 값은 메시지의 량에 들어 온 새 메시지로 오래된 메시지를 폐기하면서 프리패치 량보더 더 메시지를 유지 하게 될 것이다.  -1 값은 메시의 폐기를 비활성화 한다. 

현재 이 전략은 다른 두 구현체가 있다. :

  • 정해진 상수 지연 메시지 제한 전략 (ConstantPendingMessageLimitStrategy)
  • 프리패치 비율 지연 메시지 제한 전략 (PrefetchRatePendingMessageLimitStrategy)

정해진 상수 지연 메시지 제한 전략 (ConstantPendingMessageLimitStrategy)

이 전략은 모든 컨슈머를 위해 정해진 상수 제한값을 사용한다.  (위 프리패치 사이즈).

예제:

xml<constantPendingMessageLimitStrategy limit="50"/>

프리패치 비율 지연 메시지 제한 전략 (PrefetchRatePendingMessageLimitStrategy)

이 전략은 컨슈머들 프리패치 사이즈의 곱셈을 사용하여 지연 메시지의 최대 량을 계산한다. 그래서 예를 들면 각각의 컨슈머를 위한 프리패치 수를 2.5배 유지 할 수 있다. 

예제:

xml<prefetchRatePendingMessageLimitStrategy multiplier="2.5"/>

제한을 환경 구성하기 위해 프리패치 정책 사용하기 

JMS 클라이언트는 지속성 또는 비지속성 큐와 토픽을 위한 다양한 프리패치 정책을 환경 구성하기 위해 사용될 수 있는 프리패치 정책 을 가진다. 이 프리패치 정책은 또한 커넥션 단위 또는 컨슈머 단위로 maximumPendingMessageLimit 을 지정하는 것을 허용한다. 이 값을 환경 구성하는 하나의 작은 차이가 있다; OpenWire 같은 non-JMS 클라이언트로 동작을 단순화 하기 위해,  0값이 무시된다.; 그래서 환경구성 될수 있는 가장 낮은 값은 1이다.

퇴출 정책 환경 구성하기

속도가 느린 컨슈머에 메시지가 퇴출되는 것을 결정할때 사용하는 MessageEvictionStrategy  전략이 있다. 

하나는 가장 오래된 메시지를 퇴출 하는 것이 기본 값이고 설정은 다음과 같다:

xml<oldestMessageEvictionStrategy/>

그러나, 몇몇 어플리케이션이 퇴출을 위한 메시지를 선택하는 특별한 방법을 사용하기 위해 사용할 수 있다. 예를들면, 만약 가격을 업데이트 할 시장 데이타를 보낸다면, 가장 오래된 메시지가 아닌 오래된 가격 값을 찾는 것을 원할지 모른다.

예제:

xml<uniquePropertyMessageEvictionStrategy propertyName="STOCK"/>

propertyName 은 가격을 지정한 JMS 메시지 프로퍼티이다. 

역자주) propertyName 에 지정된 이름에 가장 오래된 메시지를 퇴출 한다.


다른 하나의 옵션은 우선 순위가 가장 낮은 메시지로 가장 오래된 메시지를 사용할 수있다. 그러므로 만약 몇몇 높은 우선순위 메시지가 있다면 심지어 새 메시지라고 하더라도 우선순위가 낮은 메시지가 퇴출된다. 


xml<oldestMessageWithLowestPriorityEvictionStrategy/>

예제

다음 예지는 ActiveMQ 브로커의 환경 구성 파일을 보여준다. Notice that for topics in the PRICES.> wildcard range the pendingMessageLimitStrategyproperty is set to only keep around 10 messages for each consumer above their prefetch buffer size.

xml

<beans xmlns="http://www.springframework.org/schema/beans"
            xmlns:amq="http://activemq.apache.org/schema/core"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://activemq.apache.org/schema/core  http://activemq.apache.org/schema/core/activemq-core.xsd">

<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"/>
    <broker xmlns="http://activemq.apache.org/schema/core" persistent="false" brokerName="${brokername}">
      <!-- lets define the dispatch policy -->
      <destinationPolicy>
        <policyMap>
          <policyEntries>

            <policyEntry topic="FOO.>">
              <dispatchPolicy>
                <roundRobinDispatchPolicy/>
              </dispatchPolicy>
              <subscriptionRecoveryPolicy>
                <lastImageSubscriptionRecoveryPolicy/>
              </subscriptionRecoveryPolicy>
            </policyEntry>

            <policyEntry topic="ORDERS.>">
              <dispatchPolicy>
                <strictOrderDispatchPolicy/>
              </dispatchPolicy>
              <!-- 1 minutes worth -->
              <subscriptionRecoveryPolicy>
                <timedSubscriptionRecoveryPolicy recoverDuration="60000"/>
             </subscriptionRecoveryPolicy>
          </policyEntry>
  
          <policyEntry topic="PRICES.>">
            <!-- lets force old messages to be discarded for slow consumers -->
            <pendingMessageLimitStrategy>
              <constantPendingMessageLimitStrategy limit="10"/>
            </pendingMessageLimitStrategy>
            <!-- 10 seconds worth -->
            <subscriptionRecoveryPolicy>
              <timedSubscriptionRecoveryPolicy recoverDuration="10000"/>
            </subscriptionRecoveryPolicy>
          </policyEntry>
  
          <policyEntry tempTopic="true" advisoryForConsumed="true"/>
          <policyEntry tempQueue="true" advisoryForConsumed="true"/>

        </policyEntries>
      </policyMap>
    </destinationPolicy>
  </broker>
</beans>

사용 팁

만약 특정한 컨슈머가 속도가 느리다면 빠른 컨슈머보다 프리패치 사이즈를 더 작게 설정하는 것이 좋다!

예를 들면, 만약 특정 서버가 매우 느리고 높은 메시지 비율을 가지고 있고, 몇몇 속도가 빠른 컨슈머가 있다면, 빠른 서버 보다 더 작게 속도가 느린 서버에 프리패치를 설정하고 이 기능을 활성화 하는 것을 원할지 모른다.

속도가 느린 컨슈머 상태 모니터링 하기

활성화된 구독의 상태를 보기 위해 JMX 콘솔을 사용 할 수 있다. 이 방법은 TopicSubscriptionViewMBean에 다음 통계를 보는것을 허용한다.  

Statistic

Definition

discarded

속도가 느린 컨슈머에 구독 구독라이프 사이클 동안 폐기된 많은 메시지가 수.

matched

프리패치 버퍼에 가용량이 사용가능하자 마자 구독에 전파되게 되고 일치된 메시지의 현재 수. 그래서 0이 아닌 값은 구독을 위해 프리패치 버커가 가득 찬 것을 암시한다. 


[원문출처] http://camel.apache.org/defaulterrorhandler.html


해당 문서의 경우 Apache 재단의 Camel Document 문서 일부를 번역 한 것입니다. 
번역본인 해당 문서의 경우 역자에게 있음을 알리며 상업적 이용을 불허합니다. 

www.sogomsoft.co.kr (주) 소곰소프트 





DefaultErrorHandler

Camel 2.0 이후부터 새 기본 에러 핸들로 이다. .

 Dead Letter Channel처럼 같은 힘을 가지고 있다. 그러나 둘 사이의 단지 큰 차이점은 데드 레터 큐(dead letter queue)를 가지지 않는다

DefaultErrorHandler 는 Dead Letter Channel에서 환경 구성되었던 것과는 다르게 환경 구성 된다.:

  • 재 전송 없음
  • 처리 없음
  • 데드 레터 큐 (dead letter queue) 없음 (가능하지 않음)

기본적으로, 라우팅 되는 동안 던져진 어떤 exception 호출한 곳에 다시 전파되고 Exchange 는 바로 끝난다. 그러나, 처리된 표시함으로써 주어진 Exception 또는 더 낮은 Exception을 잡아내기 위해 Exception Clause 를 사용 할 수 있다 만약 호출한 곳에 돌려지지 않게 되면 Exchange 가 라우팅 되는 것을 계속 할 수 있다.

예제

아래 라우터에서, 안에 던져진 어떤 exception (예를 들면 validateOrder 빈) Jetty 엔드포인트를 통해서 다시 전파된다. 클라이언트에 HTTO 에러 메시지를 반환하게 될 것이다. 


from("jetty:http://localhost/myservice/order").to("bean:validateOrder").to("jms:queue:order");

이 경우에 다르게 확실한 Exception과 라우터를 잡아내기를 원하면 onException 을 추가 할 수 있다. 예를 들면 ValidationException을 잡아 내기 위해 호출한 곳에 고정된 응답을 반환 한다. d return a fixed response to the caller.


onException(ValidationException.class).handled(true).transform(body(constant("INVALID ORDER")));

 from("jetty:http://localhost/myservice/order").to("bean:validateOrder").to("jms:queue:order");

validateOrder 빈으로부터 ValidationException 이 발생했을 때, DefaultErrorHandler에 의해 인터셉터되고 onException(ValidationException.class)가 그 에러를 처리 하게 한다. 그래서 Exchange가 onException 라우터에 라우팅되고 handled(true) 를 사용할 때, 원본 Exception은 제거되고 고정된 응답 값으로 jetty 엔드포인트에 돌려줄 원래 호출한 곳에 반환될 메시지를 변형한다.

참고


[원문출처] http://camel.apache.org/dead-letter-channel.html


해당 문서의 경우 Apache 재단의 Camel Document 문서 일부를 번역 한 것입니다. 
번역본인 해당 문서의 경우 역자에게 있음을 알리며 상업적 이용을 불허합니다. 

www.sogomsoft.co.kr (주) 소곰소프트 




데드 레터 채널(Dead Letter Channel)

Camel은 Error Handler인 DeadLetterChannel를 사용하여 EIP patterns으로 부터 Dead Letter Channel을 지원한다.

데드 레터 채널 (Dead Letter Channel) 과 기본 에러 핸들러의 차이

기본 에러 핸들러는 매우 작다:  Exchange가 즉시 끝나고 호출한 곳에 던져진 Exception을 전달한다.

데드 레터 채널(Dead Letter Channel)은 재 전송을 포함하는 행위(호출한 곳에 던져진 Exception을 전파 할 것인지 여부, 실패 했을때 전달 해야 할 곳 등)을 조절 하는 것을 허용한다.

데드 레터 채널(Dead Letter Channel)은 또한 로그에서 verbose 모드가 아니게 환경 구성되어 있다. 그래서 메시지가 핸들링되고 데드 레터 엔드포인트에 옮겨 질 때 아무것도 로깅 되지 않는다. 만약 몇몇 로깅 레벨을 원하면 재전송 정책 / 환경 구성하기 위한 데드 레터 채털 상에 다양한 옵션을 사용할 수 있다. 예를 들면 만약 메시지 히스토리를 원하면 logExhaustedMessageHistory=true를 설정한다. (Camel 2.15.x 나 그 이후 버전은 logHandled=true로 설정한다. ).

DeadLetterChannel 이 데드 레터 엔드포인트에 메시지를 이동할 때 역시 기본적으로 데드 레터 채널에 의해 새로운 Exception이 핸들링 된다.  DeadLetterChannel이  항상 성공 하는 것을 보장한다. Camel 2.15 이후부터 이 행위는 deadLetterHandleNewException=false 옵션을 설정함으로써 변경 될 수 있다. 그래서 만약 새로운 Exception이 던져지게 될 때 데드 레터 채털(dead letter channel)은 실패하게 되고 기본 에러 핸들러의 행위인 새 Exception을 다시 돌려준다. (역주: 데드 레터 채널은 항상 성공이고 에러를 돌려주지 않으나 기본 에러 핸들러는 에러 발생시 바로 호출 한 곳으로 에러를 전파한다.). 새 Exception이 발생 했을 때 데드 레터 채널(dead letter channel) WARN 레벨로 로깅한다. logNewException=false를 설정함으로써 이 기능을 끌 수 있다..

재전송

임시 정전 또는 데이터베이스 데드락 때문에 메시지를 처리 하는데 실패 하는 원인이 되는 것이 일반적이다.그러나 만약 몇 초의 딜레이로 몇번  재시도 하면 완전히 좋게 될 것이다. 그래서 일반적으로 재전송을 시도하기 전에 얼마나 많이 메시지를 재 전송하기를 원하는지 그리고 얼마나 오래 기다릴 것인지 같은 몇몇 재 전송 정책을 사용하는 것을 원한다.

재 전송 정책(RedeliveryPolicy)은 재전송될 메시지를 어떻게 할 것인지 정의한다. 다음처럼 커스터마이징 할 수 있다.

  • 실패로 간주하고 데드 레터 채널로 보내기 전에 얼마나 많이 재 전송되는 것을 시도 하는가
  • 초기화 재 전송 타임아웃 
  • 지수 백오프 알고리즘을 사용하는지 아닌지 ( 예를 들면, 백오프 멀티플라이어를 사용하여 재시도 시간 간격 증가)
  • 충돌을 피하기 위해 타이밍에 약간의 랜덤을 추가할 것인지
  • 지연 패턴 (자세한 내용은 아래 참고)
  • Camel 2.11: 멈추는 중이거나 셧다운 중일 때 재 전송을 허용할 것인지 아닌지

메시지를를 재 전송하는 모든 시도가 실패하면 메시지는 데드 레터 큐(dead letter queue)로 보내진다.

Exchange가 데드 레터 큐(dead letter queue)에 옮겨지고 처리되는 방법

Dead Letter Channel 에서 처리

모든 재 전송 시도가 실패 했을때 Exchange 가 데드 레터 큐(dead letter queue: dead letter endpoint)로 이동된다. Exchange는 완료되고 뷰의 클라이언트 포인트로부터 처리되게 될 것이다.이와 같이Dead Letter Channel이 Exchange를 처리한다.

예를 들면 다음처럼 데드 레터 채널에 환경 구성한다. :

Fluent Builders를 사용


errorHandler(deadLetterChannel("jms:queue:dead").maximumRedeliveries(3).redeliveryDelay(5000));

Spring XML Extensions을 사용


<route errorHandlerRef="myDeadLetterErrorHandler">
   ...
</route>
 
<bean id="myDeadLetterErrorHandler" class="org.apache.camel.builder.DeadLetterChannelBuilder">
    <property name="deadLetterUri" value="jms:queue:dead"/>
    <property name="redeliveryPolicy" ref="myRedeliveryPolicyConfig"/>
</bean>
 
<bean id="myRedeliveryPolicyConfig" class="org.apache.camel.processor.RedeliveryPolicy">
    <property name="maximumRedeliveries" value="3"/>
    <property name="redeliveryDelay" value="5000"/>
</bean>

위 Dead Letter ChannelExchange.EXCEPTION_CAUGHT 을 키값으로 하는 Exchange의 프로퍼티에 발생된 Exception을 옮김으로써 발생된 Exception(setException(null))을 클리어한다. 그러면 Exchange는 "jms:queue:dead" 에 옮겨지게 되고 클라이언트는 실패를 통보하지 않는다.

Exchange가 데드 레터 큐(dead letter queue)에 옮겨지고  원본 메시지를 사용하는 방법

useOriginalMessage 옵션이 라우팅 하는 동안 잠재적으로 수정된 현재의 메시지 대신에 원본 입력 메시지를 라우팅 하기 위해 사용된다.

예를 들면 다음 라우터를 사용하면 :


from("jms:queue:order:input")
    .to("bean:validateOrder")
    .to("bean:transformOrder")
    .to("bean:handleOrder");

이 라우터는 JMS 메시지를 리스닝하고 검증하고 변형하고 처리 한다. 이 Exchange 페이로드가 변형되고 변경되는 동안 이 경우 무언가 잘못되었기 때문에 다른 JMS destination으로 메시지를 옮기기를 원한다. 그러면 우리는 useOriginalMessage 옵션으로 Dead Letter Channel 에 환경 구성할 수 있다.  그러나 destination에 Exchange 가 옮겨졌을 때 이 안에 있는 메시지의 상태를 우리는 알지 못한다. transformOrder 이전에 또는 이후에 에러가 발생했는가? 그래서 jms:queue:order:input 로부터 받은 원본 입력 메시지를 옮기는 것을 원하는지 확인 해야 한다. 그래서 아래처럼 useOriginalMessage 옵션을 활성화함으로써 가능하다.:


// will use original body
errorHandler(deadLetterChannel("jms:queue:dead")
   .useOriginalMessage().maximumRedeliveries(5).redeliverDelay(5000);

그러면 jms:queue:dead에 라우팅된 메시지는 원본 입력 값이다. 만약 수동으로 재 시도 하는 것을 원하면 Input 큐에 JMS 메시지를 옮길 수 있다. 메시지가 아무런 문제가 없다면 메시지는 우리가 수신 받은 원본과 같다.

OnRedelivery

Dead Letter Channel이 재 전송 중 일 때, 매번 재 전송을 시도하기 전에 실행되는 Processor를 환경 구성 하는 것이 가능하다. 재전송 되기 전에 메시지를 바꿀 필요가 있는 상황에서 사용 될 수 있다. 아래 다음 예제를 보라..

onException 과 onRedeliver

onException 당 onRedeliver를 설정하는 것을 지원한다. 이 말의 의미는 다른 Exception을 위해 특정 재 전송을 할 수 있다는 것이다. 반대로 Dead Letter Channel에 onRedelivery 를 설정하는 것은 위해 글로벌 스코프처럼 보여 질 수 있다.

재전송 기본 값 (Redelivery default values)

기본적으로 재 전송은 비활성화 되어 있다.

기본 재 전송 정책은 다음 값을 사용 하게 될 것이다. :

  • maximumRedeliveries=0
  • redeliverDelay=1000L (1 초)
  • maximumRedeliveryDelay = 60 * 1000L (60 초)
  • 그리고 지수 백오프 알고리즘과 충돌 방지가 꺼져있다.
  • retriesExhaustedLogLevel이 LoggingLevel.ERROR로 설정되어 있다.
  • retryAttemptedLogLevel이 LoggingLevel.DEBUG로 설정되어 있다.
  • Stack traces 가 Camel 2.2 이후부터 소모된 메시지를 위해 로깅된다.
  • Camel 2.3 이후 부터 처리된 exception들은 로딩되지 않는다. 
  • 기본 에러 핸들러를 위해 logExhaustedMessageHistory가 true이다. 그리고 데드 레터 채널(dead letter channel)을 위해 false 이다.
  • Camel 2.17: logExhaustedMessageBody은 기본적으로 민감한 메시지의 Body와 Header 상세 로깅을 피하기 위해  비활성화 되어 있다.만약 이 옵션이 true이면, logExhaustedMessageHistory 옵션도 true여야만 한다..

최대 재 전송 지연 시간은 그 값 보다 지연시간이 더 길지 않다는 것을 보장한다.  기본값 1분. 지수 오프백 알고리즘이 켜져 있다면 발생 할 수 있다.

최대 재 전송은 재 전송을 시도할  수 이다. 기본적으로 Camel은 Exchange 1 + 5회를 처리 하기 위해 시도한다. 일반 시도 1회, 재전송으로 5회 시도한다. 
maximumRedeliveries에 -1과 같은 음수를 설정하면 항상 재 전송한다. (제한 없음).
maximumRedeliveries에 0을 설정하면 어떠한 재 전송 시도도 비활성화 된다.

Camel은 기본적으로 DEBUG 레벨에 전송 실패를 로깅하게 될 것이다. retriesExhaustedLogLevel 또는 를 지정함으로써 변경 할 수 있다. 예지는 ExceptionBuilderWithRetryLoggingLevelSetTest 를 보라 

stack traces의 로깅을 켜고 끌수 있고 만약 꺼져있다면 Camel은 여전히 재 전송 시도를 로깅 하게 될 것이다. 단지 많이 덜 자세한 로그이다.

재 전송 지연 패턴 

지연 패턴은 지연을 위한 범위 패턴을 설정하기 위한 단일 옵션처럼 사용된다. 만약 사용되면 다음 옵션(delay, backOffMultiplier, useExponentialBackOff, useCollisionAvoidance, maximumRedeliveryDelay)은 적용되지 않는다.

다음 구문을 사용하여 범위의 그룹을 설정한다. : limit:delay;limit 2:delay 2;limit 3:delay 3;...;limit N:delay N

각각의 그룹은 콜론으로 구분된 두 값을 가진다.

  • limit = 상위 제한 limit
  • delay = 밀리세컨드 지연시간
    그리고 그룹은 다시 세비 콜론으로 구분된다.
    다음 그룹이 이전 그룹보다 더 높은 제한을 가져야 하는 것은 경험 법칙이다.

다음 예로 명확하게 해보자:
delayPattern=5:1000;10:5000;20:20000

3개 그룹들이 주어졌다.:

  • 5:1000
  • 10:5000
  • 20:20000

재 전송 시도를 위한 3개의 지연시간의 결과:

  • 재 전송 시도 1..4회차 = 0 millis (첫번째 그룹이 5부터 시작 하므로)
  • 재 전송 시도 5..9회차 = 1000 millis (첫번째 그룹)
  • 재 전송 시도 10..19회차 = 5000 millis (두번째 그룹)
  • 재 전송 시도 20..회차 이상 = 20000 millis (마지막 그룹)

주의 : 첫번째 재 전송 시도는 1 이다 첫번째 그룹은 1부터 시작하거나 더 커야 한다. 

제한이 1부터 시작하는 그룹으로 지연 시간이 시작 될 수 있다. : delayPattern=1:1000;5:5000

  • 재 전송 시도 1..4회차 = 1000 millis (첫번째 그룹)
  • 재 전송 시도 5..회차 이상 = 5000 millis (마지막 그룹)

다음 지연시간이 이전 보다 높아야 할 필요는 없다. 원하는 지연 시간 값을 사용할 수있다. 예를 들면  delayPattern=1:5000;3:1000, 5초 단위로 지연 시간을 가지고 시작해서 마지막에는 1초 단위로 감소한다. 

재 전송 헤더 (Redelivery header)

메시지가 재 전송 될 때, DeadLetterChannel은 얼마나 많은 재 전송 시도를 하였는지 표시하기 위해 메시지에 사용자 정의 헤더를 추가 한다. 
Camel 2.6 이전 버전: 헤더는 Exchange.REDELIVERY_COUNTER에 정의된 CamelRedeliveryCounter이다.

Camel 2.6 이후 부터: 헤더는 최대 전송을 설정 하는 것을 포함하는 Exchange.REDELIVERY_MAX_COUNTER에 정의된 CamelRedeliveryMaxCounter이다. 만약 retryWhile 을 사용하거나 또는 환경 구성된 최대 재 전송에 제한이 없으면 이 헤더 값은 존재 하지 않는다. 

그리고 불린 값으로 재 전송 될지 아닌지를 판단. (첫번째 시도에서)
헤더 값 CamelRedelivered은 불린 값으 포함한다. 만약 재 전송 되거나 아니거나 이면 Exchange.REDELIVERED 에 정의 되어 있다. 

exchange로 부터 동적으로 계산된 지연 시간.
Camel 2.9 또는 2.8.2에서 : 헤더 값 CamelRedeliveryDelayExchange.REDELIVERY_DELAY에 정의 되어 있고 이 헤더 값이 없으면 일반 재 전송 률이 적용된다..

어느 엔드포인트가 실패인가?

Camel 2.1부터 가능 한 것

Camel이 메시지를 라우터 할 때 마지막 엔드포인트를 포함하는 속성을 가진 Exchange 장식한다. Camel은 Exchange 를 보낸다. :


String lastEndpointUri = exchange.getProperty(Exchange.TO_ENDPOINT, String.class);

Exchange.TO_ENDPOINT 는 CamelToEndpoint 상수 값을 가진다. .

이 정보는 Camel이 어떤 엔드 포인트에 메시지를 보낼때 업데이트 된다. 그래서 만약 존재 하면 카멜이 Exchange를 보낸 마지막 엔드 포인트 이다. 

예를 들면 주어진 Endpoint 에 Exchange를 처리하거나 그 메시지가 데드 레터 큐(dead letter queue)로 옮겨 질 때  Camel은 또한 마지막 엔드포인트를 포함하는 또 다른 프로퍼티를 Exchange를 장식한다.:


String failedEndpointUri = exchange.getProperty(Exchange.FAILURE_ENDPOINT, String.class);

Exchange.FAILURE_ENDPOINT 는 CamelFailureEndpoint 상수 값을 가진다..

예를 들면 데드 레터 큐(dead letter queue)에 정보를 패치하고 에러 리포팅을 위해 사용하는 것을 허용한다. 

만약 Camel 라우터가 동적 Recipient List  같은 동적 비트이면 실패한 엔드포인트를 알 수 있다.

주의: 그 정보들은 주어진 엔드포인트에 의해 심지어 메시지가 성공적으로 처리되더라도  Exchange에 유지된다. 그리고 예를 들면 로컬 Bean 에서 마지막 실패는 대신 처리 된다.  그래서 정확한 에러를 돕는 힌트를 조심해야 한다. 

from("activemq:queue:foo")
    .to("http://someserver/somepath")
    .beanRef("foo");

이제 위 라우터가 foo 빈에서 실패가 발생하는 것을 가정한다. 그러면 Exchange.TO_ENDPOINT 와 Exchange.FAILURE_ENDPOINT가 여전히 http://someserver/somepath 값을 포함하게 될 것이다 .

OnPrepareFailure

Camel 2.16부터 가능

exchange가 데드 레터 큐(dead letter queue)에 보내지기 전에, you can use onPrepare to allow a custom Processor to prepare the exchange를 준비하기 위해 Exchange가 왜 실패 했는지 정보를 추가 하는 것 같은 사용자 정의 Processor 를 허용하기 위해  onPrepare 를 사용 할 수 있다.  예를 들면 다음 프로세서는 Exception 메시지를 헤더에 추가한다.

public static class MyPrepareProcessor implements Processor {
    @Override
    public void process(Exchange exchange) throws Exception {
        Exception cause = exchange.getProperty(Exchange.EXCEPTION_CAUGHT, Exception.class);
        exchange.getIn().setHeader("FailedBecause", cause.getMessage());
    }
}

그리고 다음처럼 프로세서를 사용하기 위해 에러 핸들러를 환경 구성한다. :


errorHandler(deadLetterChannel("jms:dead").onPrepareFailure(new MyPrepareProcessor()));

 

XML DSL으로 환경 구성하는 것은 다음 보여지는 것과 같다. :

<bean id="myPrepare"
      class="org.apache.camel.processor.DeadLetterChannelOnPrepareTest.MyPrepareProcessor"/>
 
 
  <errorHandler id="dlc" type="DeadLetterChannel" deadLetterUri="jms:dead" onPrepareFailureRef="myPrepare"/>

 

The onPrepare is also available using the default error handler.

Which route failed

Available as of Camel 2.10.4/2.11

When Camel error handler handles an error such as Dead Letter Channel or using Exception Clause with handled=true, then Camel will decorate
the Exchange with the route id where the error occurred.

String failedRouteId = exchange.getProperty(Exchange.FAILURE_ROUTE_ID, String.class);

The Exchange.FAILURE_ROUTE_ID have the constant value CamelFailureRouteId.

This allows for example you to fetch this information in your dead letter queue and use that for error reporting.

stopping/shutdown 되는 동안 재 전송이 허용될 때 컨트롤

Camel 2.11이후부터 가능

Camel 2.10 이전은, Camel 라우터가 멈추거나 Camel이 셧다운 되는 동안 재 전송을 수행하게 될 것이다. 이것이 Camel 2.10는 적극적으로 셧다운되는동안은 재 전송 시도를 수행하지 않는 것 처럼 조금 개선 되었다. (예를 들면 Graceful Shutdown 동안 그리고 타임아웃을 입력하면). Camel 2.11 이후부터 재 전송을 허용하는지 아닌지 컨트롤 하기 위해 사용할 수 있는 새 옵션 allowRedeliveryWhileStopping이 있다.; 어진행중엔 어떠한 재 전송도 여전히 실행 되는 것에 주의하라 이 옵션은 단지 route가 멈추는 중이거나 / Camel이 shutdown이 실행된 이후에  어떤 재 전송이 실행되는 것은 허용하지 않는다. 만약 재 전송이 허용되지 않는다면, Exchange 에 RejectedExcutionException 설정 될 것이고  Exchange 정지 처리를 한다. 그 의미는 모든 Comsumer는 RejectedExecutionException 실패로 Exchange 를 보게 될 것이다.   

역주) Route가 정지되거나 Camel이 셧다운되면 진행중인 프로세스는 모드 Exchange RejectedExcutionException 으로 오류 처리 한 후에 정지 및 셧다운이 수행된다.

이전 처럼 이전 버전과 호환 가능하게 되는 것은 기본 값은 true이다 to be backwards compatible as before. 예를 들면 다음 예제는 어떻게  Java DSL 과 XML DSL를 사용 하는지를 방법을 보여 준다.

// this error handler will try up till 20 redelivery attempts with 1 second between.
// however if we are stopping then do not allow any redeliver attempts.
errorHandler(defaultErrorHandler()
        .allowRedeliveryWhileStopping(false)
        .maximumRedeliveries(20).redeliveryDelay(1000).retryAttemptedLogLevel(LoggingLevel.INFO));
 
from("seda:foo").routeId("foo")
    .to("mock:foo")
    .throwException(new IllegalArgumentException("Forced"));

그리고 XML DSL로  사용하는 샘플

<!-- notice we use the errorHandlerRef attribute to refer to the error handler to use as default -->
   <camelContext errorHandlerRef="myErrorHandler" xmlns="http://camel.apache.org/schema/spring">
 
    <!-- configure error handler, to redeliver up till 10 times, with 1 sec delay
         and if we are stopping then do not allow redeliveries, to stop faster -->
    <errorHandler id="myErrorHandler" type="DefaultErrorHandler">
        <redeliveryPolicy maximumRedeliveries="20" redeliveryDelay="1000" allowRedeliveryWhileStopping="false" retryAttemptedLogLevel="INFO"/>
    </errorHandler>
 
       <route id="foo">
           <from uri="seda:foo"/>
        <to uri="mock:foo"/>
        <throwException ref="forced"/>
       </route>
 
   </camelContext>

샘플

다음 예제는 DSL을 사용하여 Dead Letter Channel을  어떻게 환경 구성하는지를 보여 준다. 

RouteBuilder builder = new RouteBuilder() {
    public void configure() {
        // using dead letter channel with a seda queue for errors
        errorHandler(deadLetterChannel("seda:errors"));
 
        // here is our route
        from("seda:a").to("seda:b");
    }
};

이 예제로 RedeliveryPolicy을 환경 구성할 수 있다.

RouteBuilder builder = new RouteBuilder() {
    public void configure() {
        // configures dead letter channel to use seda queue for errors and use at most 2 redelveries
        // and exponential backoff
        errorHandler(deadLetterChannel("seda:errors").maximumRedeliveries(2).useExponentialBackOff());
 
        // here is our route
        from("seda:a").to("seda:b");
    }
};

어떻게 재 전송 전에 Exchange 를 변경 할 수 있는가?

Dead Letter Channel 에서 직접적으로 각각의 재 전송 시도 이전에 수행되어야 할 Processor 를 설정 하는 것을 지원한다. 

Dead Letter Channel이 재 전송이 수행 될 때, 모든 재 전송 시도 이전에 단지 실행할 Processor 를 환경 구성하는 것이 가능하다. 재 전송 이전에 메시지를 변경할 필요가 있을 때 어느 상황에서나 사용 될 수 있다. 

여기 각각의 재 전송 이전에 수행될 MyRedeliveryProcessor 를 사용하기 위해 Dead Letter Channel을 환경 구성한다.

// we configure our Dead Letter Channel to invoke
// MyRedeliveryProcessor before a redelivery is
// attempted. This allows us to alter the message before
errorHandler(deadLetterChannel("mock:error").maximumRedeliveries(5)
        .onRedelivery(new MyRedeliverProcessor())
        // setting delay to zero is just to make unit testing faster
        .redeliveryDelay(0L));

그리고 메시지를 변경할 곳에서 MyRedeliveryProcessor 이다..

// This is our processor that is executed before every redelivery attempt
// here we can do what we want in the java code, such as altering the message
public class MyRedeliverProcessor implements Processor {
 
    public void process(Exchange exchange) throws Exception {
        // the message is being redelivered so we can alter it
 
        // we just append the redelivery counter to the body
        // you can of course do all kind of stuff instead
        String body = exchange.getIn().getBody(String.class);
        int count = exchange.getIn().getHeader(Exchange.REDELIVERY_COUNTER, Integer.class);
 
        exchange.getIn().setBody(body + count);
 
        // the maximum redelivery was set to 5
        int max = exchange.getIn().getHeader(Exchange.REDELIVERY_MAX_COUNTER, Integer.class);
        assertEquals(5, max);
    }
}

무슨 이유로 데드 레터 채널이 호출 되었는지 어떻게  로그 기록 할 수 있나 ?

종종 무엇이 잘못되어 데드 레터 채널이 발생되어 갔었는지 알 필요가 있다. 그러나 이 목적을 로깅 하는 것을 제공하지는 않는다. 그래서 Dead Letter Channel의 엔드포인트는 자신의 엔드 포인트에 설정 될 필요가 있다. (direct:deadLetterChannel 처럼). 우리는 실패한 Exchange 를 옮기기를 원하는 곳 앞에 Exchange 를 받아 들이고 Exception을 로그 기록하기 위해 라우터를 작성한다. (예를 들면 DLQ 큐라 할지라도).  http://stackoverflow.com/questions/13711462/logging-camel-exceptions-and-sending-to-the-dead-letter-channel를 보라

이패턴 사용하기 

만약 EIP 패턴을 사용하는 것을 원하면 Getting Started를 읽어라. 아마 특별히 Endpoint 와 URIs 상세한 묘사하는 유용한 아키텍처를 찾을 수 있을 것이다.  그러면 당신은 패턴을 찾는 것을 시도하기 전에 이 예제(Examples )를 시도할 수 있습니다. 




[원문출처] http://camel.apache.org/error-handler.html


해당 문서의 경우 Apache 재단의 Camel Document 문서 일부를 번역 한 것입니다. 
번역본인 해당 문서의 경우 역자에게 있음을 알리며 상업적 이용을 불허합니다. 

www.sogomsoft.co.kr (주) 소곰소프트 




에러 핸들러(Error Handler)

Camel은 이벤트 기반 Consumer가 에러 처리하는 것을 다루기 위해 플러그인 가능한 ErrorHandler 전략들을 제공한다. 예외 절(Exception Clause)를 사용하여 DSL에서 직접 에러 핸들링을 지정하는 것은 선택적이다.  

소개와 배경 지식를 위해  Error handling in Camel 을 보라.

예외 절(Exception Clause)

Error Handler 가 Exception Clause을 결합하여 사용하는 것은 매우 파워풀한 결합이다. 최종사용자(end-users)들이 에러를 핸들링하는 전략에서 이것을 조합하는 것을 권장한다. 샘플과 Exception Clause를 보라.

try ... catch ... finally 사용하기

라우터에서 직접 사용할 수 있는 DSL 처럼 에러 핸들링과 관련된 것이 Try Catch Finally 이다. 기본적으로 자바에서 try catch finally 를 모방이지만 더 파워풀하다.

현재 Camle 구현체들이 다음 특별한 기능을 제공한다. :

비 트랜잭션 (Non transacted : 트랜잭션을 지원하지 않는)

  • DefaultErrorHandler 는 Camel 에서 기본 에러 핸들러이다. 이 에러 핸들러는 데드 레터 큐(dead letter queue)를 지원하지 않고 호출한 곳에 exception을 전달하게 될 것이다. 만약 전혀 에러 핸들러가 없다면 Features의 설정에 제한을 가진다.
  • Dead Letter Channel 는 데드 레터 엔드포인트에 보내기 전에 메시지 교환의 횟수를 재 전송하기 위해 시도하는 것을 지원한다.
  • LoggingErrorHandler는 단지 Exception을 잡아내고 로깅하기 위한 것이다.
  • NoErrorHandler 는 어떠한 에러 핸들링도 없는 것이다.

트랜잭션 (Transacted : 트랜잭션을 지원하는)

에러 핸들러들은 다음 예에서 보여주는 것처럼 DSL에서 룰 전체 또는 특정 라우팅 룰에 지원 될 수 있다. 에러 핸들러 룰들은 단일 RouteBuilder 안에서 각각 라우팅하는 룰 위에 상속 된다. 

제공되는 에러 핸들러의 간단한 요약

DefaultErrorHandler

DefaultErrorHandler 는 Camel 에서 기본에러 핸들러이다. Dead Letter Channel 와 다르게 어떠한 데드 레터 큐(dead letter queue)를 가지고 있지 않다. 그리고 기본적으로 Exception들을 핸들링 하지 않는다.

Dead Letter Channel

Dead Letter Channel은 1초 딜레이를 사용하여 최대 6번의 재 전송을 할 것이다. 만약 exchange가 실패 하면 ERROR 레벨에 로깅 될 것이다.

사용하기 위해 기본 데드 레터 엔드포인트를 환경 설정 할 수 있다. :

RouteBuilder builder = new RouteBuilder() {
    public void configure() {
        // using dead letter channel with a seda queue for errors
        errorHandler(deadLetterChannel("seda:errors"));
 
        // here is our route
        from("seda:a").to("seda:b");
    }
};

또는 in Spring DSL 에서

<bean id="deadLetterErrorHandler" class="org.apache.camel.builder.DeadLetterChannelBuilder">
  <property name="deadLetterUri" value="log:dead"/>
</bean>
 
<camelContext errorHandlerRef="deadLetterErrorHandler" xmlns="http://camel.apache.org/schema/spring">
  ...
</camelContext>

또는 Camel 2.3.0 이후 부터 또한

<camel:errorHandler id="deadLetterErrorHandler" type="DeadLetterChannel" deadLetterUri="log:dead">
 
<camel:camelContext errorHandlerRef="deadLetterErrorHandler">
  ...
</camel:camelContext>

Logging Error Handler

로깅 에러 핸들러는 캐치되지 않은 Exception이 던져 질 때 마다 기본적으로 ERROR 레벨에 로깅 될 것이다. 로깅 카테고리, 로거, 레벨은 빌더에서 모두 정의 될 수 있다.


errorHandler(loggingErrorHandler("mylogger.name").level(LoggingLevel.INFO));

또는 Spring DSL 에서

<bean id="loggingErrorHandler" class="org.apache.camel.builder.LoggingErrorHandler">
  <property name="logName" value="mylogger.name"/>
  <property name="level" value="DEBUG"/>
</bean>
 
<camelContext errorHandlerRef="loggingErrorHandler" xmlns="http://camel.apache.org/schema/spring">
  ...
</camelContext>

또는 Camel 2.3.0 이후 부터 또한

<camel:errorHandler id="loggingErrorHandler" type="LoggingErrorHandler" logName="mylogger.name" level="DEBUG"/>
 
<camel:camelContext errorHandlerRef="loggingErrorHandler">
  ...
</camel:camelContext>

이것은 카테고리는 mylogger.name 을 사용하여 에러 핸들러를 생성하게 되고 그리고 모든 로그 메시지를 생성하기 위해 INFO 레벨을 사용한다.


from("seda:a").errorHandler(loggingErrorHandler("mylogger.name").level(LoggingLevel.DEBUG)).to("seda:b");

또 로거는 특정 라우터를 위해서 정의 될 수 있다. may also be defined for specific routes.

No Error Handler

no error handler는 에러 핸들링을 비활성화 하기 위해 사용된다.


errorHandler(noErrorHandler());

또는 Spring DSL에서

<bean id="noErrorHandler" class="org.apache.camel.builder.NoErrorHandlerBuilder"/>
 
<camelContext errorHandlerRef="noErrorHandler" xmlns="http://camel.apache.org/schema/spring">
  ...
</camelContext>

또는 Camel 2.3.0 이후 부터 또한

<camel:errorHandler id="noErrorHandler" type="NoErrorHandler"/>
 
<camel:camelContext errorHandlerRef="noErrorHandler">
  ...
</camel:camelContext>

TransactionErrorHandler

TransactionErrorHandler는 Camel에서 트랜잭션이 적용된 라우터를 위한 기본 에러 헨들러이다. 

만약 트랜잭션을 지원하는 DSL을 사용하여 트랜잭션으로 라우터를 만들면 Camel은 자동적으로 TransactionErrorHandler를 사용하게 될 것이다. 글로벌 또는 라우터당 환경 구성된 에러 핸들러를 찾으려고 시도하게 될 것이고 만약 TransactionErrorHandlerBuilder 인스턴스이면 그걸 사용하게 될 것이다. 만약 Camel에서 찾지 못하면 기본 에러 핸들러를 우선하는 임시 TransactionErrorHandler가 자동으로 생성되게 될 것이다. 환경 구성을 통한 규칙이다.

다양한 Error Handlers의 기능들을 지원한다.

Error Handler(들)에 의해 지원되는 기능이 여기 있다. :

위 기능들의 일부의 문서는 Exception 절(Exception Clause) 문서를 보라.

Scopes

에러 핸들러의 스코프는 다음 중 하나 이다.

  • global
  • route 당

다음 예는 어떻게 글로벌 에러 핸들러를 등록하는지를 보여준다. (이 경우에서는 logging handler를 사용한다.)

RouteBuilder builder = new RouteBuilder() {
    public void configure() {
        // logging error handler를 사용
        errorHandler(loggingErrorHandler("com.mycompany.foo"));
 
        // 여기서 표준 라우터이다.
        from("seda:a").to("seda:b");
    }
};

다음 예는 어떻게 라우터에 특정 에러 핸들러를 등록할 수 있는지를 보여 준다. 커스터마이징 된 로그 핸들러는 단지 Endpoint seda:a로 부터 라우터를 위해서 등록된다. 

RouteBuilder builder = new RouteBuilder() {
    public void configure() {
        // 이 라우터는 중첩된 로깅 에러 핸들러를 사용하고 있다.
        from("seda:a")
            // 여기에 logging error handler를 환경 구성한다..
            .errorHandler(loggingErrorHandler("com.mycompany.foo"))
            // 그리고 여기로 라우팅을 계속 한다.
            .to("seda:b");
 
        // 이 라우터는 기본 에러 핸들러 (DeadLetterChannel)을 사용하게 될 것이다.
        from("seda:b").to("seda:c");
    }
};

Spring 기반의 환경 구성

Java DSL 대 Spring DSL

에러 핸들러는 Java DSL과 Spring DSL 에서 크게 다르게 환경 설정 된다. Jaba DSL은 능숙한 빌더를 사용하는 반면에 Spring DSL은 표준 Spring Bean 환경에 더 의존한다.

에러 핸들러는 스프링 빈과 다음 스코프 에서 처럼 환경 구성 될 수 있다. :

  • global (camelContext 테그)
  • route 당 (route 테그)
  • policy 당 (policy/transacted 테그)

에러 핸들러는 errorHandlerRef 속성으로 환경 구성 될 수 있다.

에러 핸들러 계층(Error Handler Hierarchy)

에러 핸들러는 상속 된다. 그래서 만약 당신이 글로벌 에러 핸들러를 설정하면 어디서든지 사용 가능하다. 그러나 라우터에서 또는 다른 에러 핸들러를 사용하여 오버라이딩 할 수 있다. 

Spring 기반 환경 구성 예제

이 예에서 라우터에서 최종 3번과 재시도 전에 약간의 딜레이로 재전송하는 라우터에서 Dead Letter Channel 을 환경 구성한다.

먼저 route 테그에서 errorHandlerRef 속성을 사용하여 myDeadLetterErrorHandler 에 참조를 환경 설정한다..

  <camelContext xmlns="http://camel.apache.org/schema/spring">
      <template id="myTemplate"/>
<!-- DeadLetterChannel에 errorHandlerRef 를 설정, 단지 이 라우터를 위해서만 적용된다. -->
      <route errorHandlerRef="myDeadLetterErrorHandler">
          <from uri="direct:in"/>
          <process ref="myFailureProcessor"/>
          <to uri="mock:result"/>
      </route>
  </camelContext>

그리고 Dead Letter Channel인 스프링 bean 엘리먼트를 사용하여 표준 스프링으로  myDeadLetterErrorHandler를 환경 구성한다.

그리고 마지막으로 얼마나 많이 재전송할 것인지 지연시킬 것인지 등을 위한 옵션을 환경 구성할 재전송 정책을 위한 다른 Spring 빈을 가진다.

<!-- 여기 DeadLetterChannel을 환경 구성한다. -->
<bean id="myDeadLetterErrorHandler" class="org.apache.camel.builder.DeadLetterChannelBuilder">
     <!-- 재 전송 실패 시 exchange가 mock:dead 에 라우팅 된다. -->
       <property name="deadLetterUri" value="mock:dead"/>
     <!-- 사용할 재전송 정책을 참조한다. -->
       <property name="redeliveryPolicy" ref="myRedeliveryPolicyConfig"/>
</bean>
 
   <!-- 여기 재 전송 설정을 설정한다. -->
<bean id="myRedeliveryPolicyConfig" class="org.apache.camel.processor.RedeliveryPolicy">
     <!-- 최대 3번 재전송 시도하고 전송 실패 시 mock:dead endpoint에 라우팅 된다. -->
       <property name="maximumRedeliveries" value="3"/>
     <!-- 재전송 전에 delay 250ms초 지연 -->
       <property name="redeliveryDelay" value="250"/>
</bean>

Camel 2.3.0 부터, Camel은 에러 핸들러를 위하여 customer 빈 환경 구성을 제공한다.  여기 예제가 있다.

<errorHandler id="loggingErrorHandler" type="LoggingErrorHandler" logName="foo" level="INFO"
 
<!-- 만약 유형 속성이 지정되지 않으면 유형 값은 DefaultErrorHandler가 설정되게 될 것이다. -->
<errorHandler id="errorHandler" xmlns="http://camel.apache.org/schema/spring"/>
 
<!-- 에러 핸들러 안쪽에 재전송 정책(redeliveryPolicy )을 정의 할 수 있다. -->
<camel:errorHandler id="defaultErrorHandler" type="DefaultErrorHandler">
    <camel:redeliveryPolicy maximumRedeliveries="2" redeliveryDelay="0" logStackTrace="false"/>
</camel:errorHandler>
 
<camel:errorHandler id="deadLetterErrorHandler" type="DeadLetterChannel" deadLetterUri="log:dead">
    <camel:redeliveryPolicy maximumRedeliveries="2" 
redeliveryDelay="1000" 
logHandled="true" 
asyncDelayedRedelivery="true"/>
</camel:errorHandler>
 
<bean id="myErrorProcessor" class="org.apache.camel.spring.handler.MyErrorProcessor"/>
 
<!-- TX 에러 핸들러는 템플릿을 사용하여 환경 구성 될 수 있다. -->
<camel:errorHandler id="transactionErrorHandler" type="TransactionErrorHandler"
                    transactionTemplateRef="PROPAGATION_REQUIRED" onRedeliveryRef="myErrorProcessor"/>
 
<!-- 또는 트랜잭션 관리 를 사용한다. -->
<camel:errorHandler id="txEH" type="TransactionErrorHandler" transactionManagerRef="txManager"/>
 
<!-- camelContext 안쪽에 에러 핸들러를 정의 할 수 있다. -->
<camelContext errorHandlerRef="noErrorHandler" xmlns="http://camel.apache.org/schema/spring">
    <errorHandler id="noErrorHandler" type="NoErrorHandler"/>
</camelContext>

트랜잭션을 지원하는(transactional) 에러 핸들러 사용

트랜잭션 에러 핸들러는 스프링 트랜잭션을 기반으로 되어 있고 camel-spring component의 사용을 필요로 한다..
사용하는 방법과 에러 핸들러로 환경 구성하는 트랜잭션 행위와 환경 구성을 위한 많은 예가 있는 Transactional Client를 보라.

See also


[원문출처] http://camel.apache.org/error-handling-in-camel.html


해당 문서의 경우 Apache 재단의 Camel Document 문서 일부를 번역 한 것입니다.
번역본인 해당 문서의 경우 역자에게 있음을 알리며 상업적 이용을 불허합니다. 

www.sogomsoft.co.kr (주) 소곰소프트 





Camel에서 에러 핸들링 (Error handling in Camel)

카멜에서 에러 핸들링을 하는 방법은 대략 두가지 유형으로 구분 된다. :

  • non transactional (트랜잭션이 적용되지 않는)
  • transactional(트랜잭션이 적용되는)

Camel에 의해서 활성화되고 통제되는 비 트랜잭션(트랜잭션이 적용되지 않는) 유형이 가장 일반적이다. 트랜잭션(트랜잭션이 적용되는)유형은 J2EE 어플리케이션 서버처럼 지원 시스템에 해 통제된다.

try ... catch ... finally 구문 사용하기

Camel에서 Try Catch Finally 기능이 에러 핸들링에 관련된다.

에러가 발생 했을 때 (When does an error happen)

에러가 발생 했을 때 

  • Camel내에서 메시지를 라우팅하고 처리 하는 동안 처리되지 않은 Exception이 발생한다.

    그래서 모든 예외를 잡아내고 무엇을 해야 하는지 통제하는 큰 Exception 인터셉터처럼 생각한다. 

비 트랜잭션 (Non transactional : 트랜잭션이 적용되지 않는)

기본적으로 Camel은 비트랜잭션 (트랜잭션이 적용되지 않은) 유형을 사용하고 처리하고 라우팅 하는 동안 에러를 핸들링하는 것 조율한다.

모든 경우에 적용할 단일 에러 핸들링 환경구성이 없기 때문에, 필요로 하는 더 적당한 기본 환경 구성을 바꾸는 것을 고려하여야 한다.

Came 1.x 기본 에러 핸들러 (Camel 1.x default error handler)

Camel 1.x에서 기본적으로 Error Handler 로 전역 Dead Letter Channel 이 설정된다. Dead Letter Channel 은 다음처럼 환경 구성되어있다.:

  • 6번까지 재 전송.
  • 각각의 재 전송 시도마다 1초의 일시 정지
  • 만약 모든 재 전송 시도가 실패하면 데드 레터 큐(dead letter queue)로 exchange를 옮긴다. 
  • 기본 데드 레터 큐(dead letter queue)가 ERROR level (star)에 exchange를 로깅하는 로거이다. 

Dead Letter Queue (*)

데드 레터 큐(dead letter queue)는 블랙홀 같다. Exchange를 소비하게 되고 실패했다는 어떠한 표시도 없이 Exchange 라우팅이 끝난다. 

시스템의 리소스를 다 사용해버리기 때문에 잘못된 메시지가 끝없이 재시도하는 것을 원하지 않는JMS 메시징에서 이 작업은 훌륭하다. 메시지들 독이 되는 것처럼 말하고 그러므로 우리는 메시지를 데드 레터 큐(dead letter queue)에 옮겨서 시스템이 계속 조작하고 다음 메시지를 작업 할 수 있다.

기본 값은 요청/응답(request/reply) 메시징 스타일에서 사용하는 다른 Transport로 잘 되지 않는다. 만약 Exchange 실패하면 원래 요청자는 실패 되었다는 것으로 변경 되기를 원한다. 

그래서 결론은 비즈니스적 요구에 적함한 에러 핸들링을 환경 구성하고 설정해야만 한다.  

Camel 2.o 이후 기본 에러 핸들러 (Camel 2.0 onwards default error handler)

Camel 2.0 이후부터는 기본적으로 Error Handler 로 전역 DefaultErrorHandler 설정된다. DefaultErrorHandler는 다음처럼 환경 구성되어 있다. :

  • 재 전송 없음
  • 데드 레터 큐(dead letter queue) 없음
  • 만약 exchage가 실패 하면 Exception을 던지고 RuntimeCamelException에 싸서 원래 요청자에게 다시 전파한다.

Scopes

Camel은 2 Scope를 지원하고 DSL에 의해 결정된다. :

DSL

Scope 1

Scope 2

Note

XML DSL

CamelContext

route

Scope 2가 Scope 1보다 우선한다.

Java/Scala DSL

RouteBuilder

route

Scope 2가 Scope 1보다 우선한다.

XML DSL을 사용할 때 scope 1은 모든 라우터를 위해 적용한다.  Java DSL을 사용할 때  route 1은 단지 주어진 RouterBuilder 인스턴스을 위해 적용된다. 그래서 만약 복수의 RouterBuilder들을 가지고 있을 때 각각의 라우터 빌더가 자신의 Scope 1가진다.

만약 RouterBuilder 들 사이에 Scope를 공유하기를 원하면 클래스 상속을 사용할 수 있다. 기본 클래스를 생성하고 RouterBuilder들을 위해 클래스를 확장하고 super.configure() 메서드를 호출한다.

복수의 RouteBuilder 클래스를 사용할 때 scope가 영향을 받은 것은 Camel 에서 버그가 였다는 것을 신경써라 다음 CAMEL-5456 에서 자세히 보라..

어떻게 데드 레터 채널(Dead Letter Channel) 에러 핸들러가  동작을 하는가?

Camel에서 시작될 때 라우터를 검사하게 되고 라우팅에 에러 핸들링을 짜넣는다. 최대 3까지 지원되는 Scope로, 에러 핸들링이 매우 복잡해 질 수 있다. 그리고 상단에서 에러 핸들을 상속 받고 다른 특정 Exception 유형을 핸들링하기 위한 Exception Clause들을 환경 구성할 수 있다. 그래서 에러의 핸들링 할 때 진보 되었으며 매우 파워풀하다.

단순하게 유지하기 위해 먼저 어떻게 Camel이 재 전송 횟수를 조율하는지 기본 개념을 찾아 보라. 라우터 그래프에서 주어진 노드에 Camel이 현재 라우팅 되고 있는 Exchange를 가로채어서 Error Handler로 감싼다. AOP around 개념처럼 Error Handlere가 차 넣을 수 있다. 만약 Exchange가 아무런 문제 없이 라우팅 될 수 있다면 라우터 그래프에서 다음 노드로 전달 된다. 그러나 만약 Exception이 발생하면 Error Handler라 차 넣고 어떻게 할지 결정한다..

이 설명의 예제 :

errorHandler(deadLetterChannel("jms:queue:dead"));
 
from("seda:newOrder")
   .to("bean:validateOrder")
   .to("bean:storeOrder")
   .to("bean:confirmOrder");

이 라우터는 Error Handler가 감시하고 있는 3개 노드를 가지고 있다 (AOP around 방식). 그래서 seda 큐에 요청이 도착했을 때 그것을 소비하고 validateOrder 빈에 보낸다. 이 경우에 validation 빈이 정상 처리 되면 , 다음 노드로 이동한다. 이 경우에 storeOrder 빈이 실패하고 Exception을 발생 시키면 Dead Letter Channel에 의해서 걸려서 다음에 무엇을 할 것인지 결정한다. 다음 중에 하나를 한다.:

  • 재전송
  • 데드 레터 큐(dead letter queue)로 이동

정책에 환경 구성에 근거 하여 재전송하기 위해 계속 할 것 이다. 기본적으로 Dead Letter Channel은 적어도 1초의 지연 시간을 두고 6회 재 시도를 할 것이다. 그래서 만약 3번째 시도 만에 storeOrder 빈이 성공하면 다음 노드인 confirmOrder 빈에 라우팅이 계속 될 것이다.  이 경우에 모든 재전송이 실패 하면 실패로 간주되고 데드 레터 큐(dead letter queue)로 이동되고 이 exchange의 처리는 멈춘다. 기본적으로 데드 레터 큐(dead letter queue)는 단지 ERROR 로거 이다.

Camel의 모든 컴포넌트에 적용된다. 위 예제는 단지 Bean을 사용했다 그러나 FileMailVelocity  또는 사용하는 모든 컴포넌트가 같다.

트랜잭션 (Transactional: 트랜잭션이 적용되는)

Camel은 Spring transactions을 활용한다. 보통 JMS 또는 JDBC 기반처럼 제한된 전송 유형의 수만 사용 할 수 있다.  Spring 트랜잭션, J2EE 서버나 Message Broker 같은 아직 필요하다. 

어떻게 동작하는가?

Camel 1.x
Camel은 비 트랜잭션 유형처럼 같이 짜넣는다. 다른 점은 트랜잭션 Exchange를 위해 Error Handler가 차 넣을 수 없다. AOP around가 적용되지 않는다고 말 할 수 있다. Camel은 에러를 핸들링을 조율하기 위해 지원 시스템에 전적으로 의존한다. 그리고 지원시스템이 재전송 할 때 모두 다시 시작하게 된다. 예를 들면 만약 Exchange가 JMS Comsumer에 의해 시작 되었다면 JMS 메시지가 JMS 큐에 롤백되어 다시 시작하게 되고 Camel 다시 JMS 메시지를 재 소비한다.

Camel 2.0
Camel 2.0에서 TransactionErrorHandler가 DefaultErrorHandler 가 했던 것처럼 같은 기반 위에 빌드 될때 권한을 부여 받았다. 이는 트랜잭션 라우터들로 Camel 재전송을 사용하는 것을 허용한다.  Spring transaction manager가 여전히 담당하고 있고 마지막에 동작한다. 그러나 몇몇 로컬 재전송을 하기 위해 Camel을 사용할 수 있다. 예를 들면 FTP 서버에 파일을 올리기 위해 Camel에서 로컬 재전송을 사용할 수 있다. 그래서 양쪽 모두에게 유용하다.    is still in charge and have the last say. But you can use Camel to do some local redelivery, for instance to upload a file to a FTP server, in which Camel can do local redelivery. So this gives you the power from both worlds. 경우에 Camel이 Exchange가 실패 되거나 롤백 되면 재전송 할 수 없다.기본적으로 TransactionErrorHandler 는 어떤 로컬 재전송도 시도하지 않는다 그래서 로컬 재전송을 하기서 예를 들면 최대 재전송에 0보다 큰 숫자를 설정하는 환경 구성을 해야 한다. 

더 자세한 것은 Transactional Client 보라.

참조 (See also)


+ Recent posts