diff --git a/README.md b/README.md
index c7a9cf9..e40e41f 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# th2-conn-dirty-fix (1.4.1)
+# th2-conn-dirty-fix (1.4.2)
 
 This microservice allows sending and receiving messages via FIX protocol
 
@@ -49,6 +49,7 @@ This microservice allows sending and receiving messages via FIX protocol
 + *useNextExpectedSeqNum* - session management based on next expected sequence number. (`false` by default)
 + *saveAdminMessages* - defines if admin messages will be saved to internal outgoing buffer. (`false` by default)
 + *resetStateOnServerReset* - whether to reset the server sequence after receiving logout with text `Next Expected MSN too high, MSN to be sent is x but received y`.
++ *logoutOnIncorrectServerSequence* - whether to logout session when server send message with sequence number less than expected. If `false` then internal conn sequence will be reset to sequence number from server message.
 + *connectionTimeoutOnSend* - timeout in milliseconds for sending message from queue thread
   (please read about [acknowledgment timeout](https://www.rabbitmq.com/consumers.html#acknowledgement-timeout) to understand the problem).
   _Default, 30000 mls._
@@ -332,21 +333,34 @@ spec:
 
 # Changelog
 
-# 1.4.1
+## 1.4.2
+* Ungraceful session disconnect support.
+* Removed NPE when session is reset by schedule.
+
+## 1.4.1
 * Timeout on send from queue thread
   * Parameter `connectionTimeoutOnSend` was added
 
-# 1.4.0
+## 1.4.0
 * Updated bom: `4.5.0-dev`
 * Updated common: `5.4.0-dev`
 * Updated common-utils: `2.2.0-dev`
 * Updated grpc-lw-data-provider: `2.1.0-dev`
 * Updated kotlin: `1.8.22`
-
-# 1.3.0
 * Added support for th2 transport protocol
 
-# 1.2.1
+## 1.3.2
+* Improve logging: log session group and session alias for each log message.
+
+## 1.3.1
+* fix multiple consequent SOH characters
+
+## 1.3.0
+* Added handling for incoming test request messages
+* Fixed resetSeqNum flag handling on incoming logon messages.
+* Added option to automatically reset server sequence when internal conn sequence doesn't match with sequence that server sent.
+
+## 1.2.1
 * fix multiple consequent SOH characters
 
 ## 1.2.0
diff --git a/build.gradle b/build.gradle
index c08b3f9..61b30a0 100644
--- a/build.gradle
+++ b/build.gradle
@@ -51,9 +51,8 @@ dependencies {
         exclude group: 'com.exactpro.th2', module: 'task-utils'
     }
     implementation "com.exactpro.th2:common-utils:2.2.0-dev"
-
     implementation 'com.exactpro.th2:netty-bytebuf-utils:0.0.1'
-    implementation 'com.exactpro.th2:conn-dirty-tcp-core:3.2.0-dev'
+    implementation 'com.exactpro.th2:conn-dirty-tcp-core:3.2.1-mangler_fix_3.2.1+'
     implementation 'com.exactpro.th2:grpc-lw-data-provider:2.2.0-separate-executor-reverse-orders-917aa0b-SNAPSHOT'
 
     implementation 'org.slf4j:slf4j-api'
diff --git a/gradle.properties b/gradle.properties
index b74b0fc..66a2be3 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,2 +1 @@
-release_version=1.4.1
-
+release_version=1.4.2
\ No newline at end of file
diff --git a/src/main/java/com/exactpro/th2/FixHandler.java b/src/main/java/com/exactpro/th2/FixHandler.java
index ad874a4..df821be 100644
--- a/src/main/java/com/exactpro/th2/FixHandler.java
+++ b/src/main/java/com/exactpro/th2/FixHandler.java
@@ -47,6 +47,7 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.ScheduledExecutorService;
@@ -90,6 +91,7 @@
 import static com.exactpro.th2.constants.Constants.GAP_FILL_FLAG_TAG;
 import static com.exactpro.th2.constants.Constants.HEART_BT_INT;
 import static com.exactpro.th2.constants.Constants.IS_POSS_DUP;
+import static com.exactpro.th2.constants.Constants.IS_SEQUENCE_RESET_FLAG;
 import static com.exactpro.th2.constants.Constants.MSG_SEQ_NUM;
 import static com.exactpro.th2.constants.Constants.MSG_SEQ_NUM_TAG;
 import static com.exactpro.th2.constants.Constants.MSG_TYPE;
@@ -112,6 +114,7 @@
 import static com.exactpro.th2.constants.Constants.POSS_DUP;
 import static com.exactpro.th2.constants.Constants.POSS_DUP_TAG;
 import static com.exactpro.th2.constants.Constants.RESET_SEQ_NUM;
+import static com.exactpro.th2.constants.Constants.RESET_SEQ_NUM_TAG;
 import static com.exactpro.th2.constants.Constants.SENDER_COMP_ID;
 import static com.exactpro.th2.constants.Constants.SENDER_COMP_ID_TAG;
 import static com.exactpro.th2.constants.Constants.SENDER_SUB_ID;
@@ -119,11 +122,11 @@
 import static com.exactpro.th2.constants.Constants.SENDING_TIME;
 import static com.exactpro.th2.constants.Constants.SENDING_TIME_TAG;
 import static com.exactpro.th2.constants.Constants.SESSION_STATUS_TAG;
-import static com.exactpro.th2.constants.Constants.SUCCESSFUL_LOGOUT_CODE;
 import static com.exactpro.th2.constants.Constants.TARGET_COMP_ID;
 import static com.exactpro.th2.constants.Constants.TARGET_COMP_ID_TAG;
 import static com.exactpro.th2.constants.Constants.TEST_REQ_ID;
 import static com.exactpro.th2.constants.Constants.TEST_REQ_ID_TAG;
+import static com.exactpro.th2.constants.Constants.TEXT;
 import static com.exactpro.th2.constants.Constants.TEXT_TAG;
 import static com.exactpro.th2.constants.Constants.USERNAME;
 import static com.exactpro.th2.netty.bytebuf.util.ByteBufUtil.indexOf;
@@ -145,6 +148,7 @@ public class FixHandler implements AutoCloseable, IHandler {
     private static final byte BYTE_SOH = 1;
     private static final String STRING_MSG_TYPE = "MsgType";
     private static final String REJECT_REASON = "Reject reason";
+    private static final String UNGRACEFUL_DISCONNECT_PROPERTY = "ungracefulDisconnect";
     private static final String STUBBING_VALUE = "XXX";
 
     private final AtomicInteger msgSeqNum = new AtomicInteger(0);
@@ -241,7 +245,7 @@ public void onStart() {
         channel = context.createChannel(address, settings.getSecurity(), Map.of(), true, settings.getReconnectDelay() * 1000L, Integer.MAX_VALUE);
         if(settings.isLoadSequencesFromCradle()) {
             SequenceHolder sequences = messageLoader.loadInitialSequences(channel.getSessionGroup(), channel.getSessionAlias());
-            LOGGER.info("Loaded sequences are: client - {}, server - {}", sequences.getClientSeq(), sequences.getServerSeq());
+            info("Loaded sequences are: client - %d, server - %d", sequences.getClientSeq(), sequences.getServerSeq());
             msgSeqNum.set(sequences.getClientSeq());
             serverMsgSeqNum.set(sequences.getServerSeq());
         }
@@ -257,6 +261,28 @@ private CompletableFuture<MessageID> send(@NotNull ByteBuf body, @NotNull Map<St
             throw new IllegalStateException("Session is not active. It is not possible to send messages.");
         }
 
+        FixField msgType = findField(body, MSG_TYPE_TAG);
+        boolean isLogout = msgType != null && Objects.equals(msgType.getValue(), MSG_TYPE_LOGOUT);
+        if(isLogout && !channel.isOpen()) {
+            String message = String.format("%s - %s: Logout ignored as channel is already closed.", channel.getSessionGroup(), channel.getSessionAlias());
+            LOGGER.warn(message);
+            context.send(CommonUtil.toEvent(message));
+            return CompletableFuture.completedFuture(null);
+        }
+
+        boolean isUngracefulDisconnect = Boolean.parseBoolean(properties.get(UNGRACEFUL_DISCONNECT_PROPERTY));
+        if(isLogout) {
+            context.send(CommonUtil.toEvent(String.format("Closing session %s. Is graceful disconnect: %b", channel.getSessionAlias(), !isUngracefulDisconnect)));
+            try {
+                disconnect(!isUngracefulDisconnect);
+                enabled.set(false);
+                channel.open().get(settings.getConnectionTimeoutOnSend(), TimeUnit.MILLISECONDS);
+            } catch (Exception e) {
+                context.send(CommonUtil.toErrorEvent(String.format("Error while ending session %s by user logout. Is graceful disconnect: %b", channel.getSessionAlias(), !isUngracefulDisconnect), e));
+            }
+            return CompletableFuture.completedFuture(null);
+        }
+
         // TODO: probably, this should be moved to the core part
         // But those changes will break API
         // So, let's keep it here for now
@@ -275,13 +301,11 @@ private CompletableFuture<MessageID> send(@NotNull ByteBuf body, @NotNull Map<St
         }
 
         while (channel.isOpen() && !enabled.get()) {
-            if (LOGGER.isWarnEnabled()) {
-                LOGGER.warn("Session is not yet logged in: {}", channel.getSessionAlias());
-            }
+            warn("Session is not yet logged in");
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
-                LOGGER.error("Error while sleeping.");
+                error("Error while sleeping.", null);
             }
             if (System.currentTimeMillis() > deadline) {
                 // The method should have checked exception in signature...
@@ -362,14 +386,14 @@ public Map<String, String> onIncoming(@NotNull IChannel channel, @NotNull ByteBu
         FixField msgSeqNumValue = findField(message, MSG_SEQ_NUM_TAG);
         if (msgSeqNumValue == null) {
             metadata.put(REJECT_REASON, "No msgSeqNum Field");
-            if (LOGGER.isErrorEnabled()) LOGGER.error("Invalid message. No MsgSeqNum in message: {}", message.toString(US_ASCII));
+            if(LOGGER.isErrorEnabled()) error("Invalid message. No MsgSeqNum in message: %s", null, message.toString(US_ASCII));
             return metadata;
         }
 
         FixField msgType = findField(message, MSG_TYPE_TAG);
         if (msgType == null) {
             metadata.put(REJECT_REASON, "No msgType Field");
-            if (LOGGER.isErrorEnabled()) LOGGER.error("Invalid message. No MsgType in message: {}", message.toString(US_ASCII));
+            if(LOGGER.isErrorEnabled()) error("Invalid message. No MsgType in message: %s", null,  message.toString(US_ASCII));
             return metadata;
         }
 
@@ -388,11 +412,24 @@ public Map<String, String> onIncoming(@NotNull IChannel channel, @NotNull ByteBu
 
         int receivedMsgSeqNum = Integer.parseInt(requireNonNull(msgSeqNumValue.getValue()));
 
+        if(msgTypeValue.equals(MSG_TYPE_LOGON) && receivedMsgSeqNum < serverMsgSeqNum.get()) {
+            FixField resetSeqNumFlagField = findField(message, RESET_SEQ_NUM_TAG);
+            if(resetSeqNumFlagField != null && Objects.equals(resetSeqNumFlagField.getValue(), IS_SEQUENCE_RESET_FLAG)) {
+                serverMsgSeqNum.set(0);
+            }
+        }
+
         if(receivedMsgSeqNum < serverMsgSeqNum.get() && !isDup) {
-            sendLogout();
-            reconnectRequestTimer = executorService.schedule(this::sendLogon, settings.getReconnectDelay(), TimeUnit.SECONDS);
+            if(settings.isLogoutOnIncorrectServerSequence()) {
+                context.send(CommonUtil.toEvent(String.format("Received server sequence %d but expected %d. Sending logout with text: MsgSeqNum is too low...", receivedMsgSeqNum, serverMsgSeqNum.get())));
+                sendLogout(String.format("MsgSeqNum too low, expecting %d but received %d", serverMsgSeqNum.get() + 1, receivedMsgSeqNum));
+                reconnectRequestTimer = executorService.schedule(this::sendLogon, settings.getReconnectDelay(), TimeUnit.SECONDS);
+                if (LOGGER.isErrorEnabled()) error("Invalid message. SeqNum is less than expected %d: %s", null, serverMsgSeqNum.get(), message.toString(US_ASCII));
+            } else {
+                context.send(CommonUtil.toEvent(String.format("Received server sequence %d but expected %d. Correcting server sequence.", receivedMsgSeqNum, serverMsgSeqNum.get() + 1)));
+                serverMsgSeqNum.set(receivedMsgSeqNum - 1);
+            }
             metadata.put(REJECT_REASON, "SeqNum is less than expected.");
-            if (LOGGER.isErrorEnabled()) LOGGER.error("Invalid message. SeqNum is less than expected {}: {}", serverMsgSeqNum.get(), message.toString(US_ASCII));
             return metadata;
         }
 
@@ -405,18 +442,18 @@ public Map<String, String> onIncoming(@NotNull IChannel channel, @NotNull ByteBu
 
         switch (msgTypeValue) {
             case MSG_TYPE_HEARTBEAT:
-                if (LOGGER.isInfoEnabled()) LOGGER.info("Heartbeat received - {}", message.toString(US_ASCII));
+                if(LOGGER.isInfoEnabled()) info("Heartbeat received - %s", message.toString(US_ASCII));
                 checkHeartbeat(message);
                 break;
             case MSG_TYPE_LOGON:
-                if (LOGGER.isInfoEnabled()) LOGGER.info("Logon received - {}", message.toString(US_ASCII));
+                if(LOGGER.isInfoEnabled()) info("Logon received - %s", message.toString(US_ASCII));
                 boolean connectionSuccessful = checkLogon(message);
                 if (connectionSuccessful) {
                     if(settings.useNextExpectedSeqNum()) {
                         FixField nextExpectedSeqField = findField(message, NEXT_EXPECTED_SEQ_NUMBER_TAG);
                         if(nextExpectedSeqField == null) {
                             metadata.put(REJECT_REASON, "No NextExpectedSeqNum field");
-                            if (LOGGER.isErrorEnabled()) LOGGER.error("Invalid message. No NextExpectedSeqNum in message: {}", message.toString(US_ASCII));
+                            if(LOGGER.isErrorEnabled()) error("Invalid message. No NextExpectedSeqNum in message: %s", null, message.toString(US_ASCII));
                             return metadata;
                         }
 
@@ -450,17 +487,19 @@ public Map<String, String> onIncoming(@NotNull IChannel channel, @NotNull ByteBu
                     reconnectRequestTimer = executorService.schedule(this::sendLogon, settings.getReconnectDelay(), TimeUnit.SECONDS);
                 }
                 break;
-            case MSG_TYPE_LOGOUT: //extract logout reason
-                handleLogout(message);
-                break;
+            //extract logout reason
             case MSG_TYPE_RESEND_REQUEST:
-                if (LOGGER.isInfoEnabled()) LOGGER.info("Resend request received - {}", message.toString(US_ASCII));
+                if(LOGGER.isInfoEnabled()) info("Resend request received - %s", message.toString(US_ASCII));
                 handleResendRequest(message);
                 break;
             case MSG_TYPE_SEQUENCE_RESET: //gap fill
-                if (LOGGER.isInfoEnabled()) LOGGER.info("Sequence reset received - {}", message.toString(US_ASCII));
+                if(LOGGER.isInfoEnabled()) info("Sequence reset received  - %s", message.toString(US_ASCII));
                 resetSequence(message);
                 break;
+            case MSG_TYPE_TEST_REQUEST:
+                if (LOGGER.isInfoEnabled()) LOGGER.info("Test request received - {}", message.toString(US_ASCII));
+                handleTestRequest(message, metadata);
+                break;
         }
 
         resetTestRequestTask();
@@ -470,26 +509,32 @@ public Map<String, String> onIncoming(@NotNull IChannel channel, @NotNull ByteBu
         return metadata;
     }
 
+    private Map<String, String> handleTestRequest(ByteBuf message, Map<String, String> metadata) {
+        FixField testReqId = findField(message, TEST_REQ_ID_TAG);
+        if(testReqId == null || testReqId.getValue() == null) {
+            metadata.put(REJECT_REASON, "Test Request message hasn't got TestReqId field.");
+            return metadata;
+        }
+
+        sendHeartbeatTestReqId(testReqId.getValue());
+
+        return null;
+    }
+
     private void handleLogout(@NotNull ByteBuf message) {
-        if (LOGGER.isInfoEnabled()) LOGGER.info("Logout received - {}", message.toString(US_ASCII));
-        FixField sessionStatus = findField(message, SESSION_STATUS_TAG);
+        if(LOGGER.isInfoEnabled()) info("Logout received - %s", message.toString(US_ASCII));
         boolean isSequenceChanged = false;
-        if(sessionStatus != null) {
-            int statusCode = Integer.parseInt(Objects.requireNonNull(sessionStatus.getValue()));
-            if(statusCode != SUCCESSFUL_LOGOUT_CODE) {
-                FixField text = findField(message, TEXT_TAG);
-                if (text != null) {
-                    LOGGER.warn("Received Logout has text (58) tag: {}", text.getValue());
-                    String wrongClientSequence = StringUtils.substringBetween(text.getValue(), "expecting ", " but received");
-                    if (wrongClientSequence != null) {
-                        msgSeqNum.set(Integer.parseInt(wrongClientSequence) - 1);
-                        isSequenceChanged = true;
-                    }
-                    String wrongClientNextExpectedSequence = StringUtils.substringBetween(text.getValue(), "MSN to be sent is ", " but received");
-                    if(wrongClientNextExpectedSequence != null && settings.getResetStateOnServerReset()) {
-                        serverMsgSeqNum.set(Integer.parseInt(wrongClientNextExpectedSequence));
-                    }
-                }
+        FixField text = findField(message, TEXT_TAG);
+        if (text != null) {
+            LOGGER.warn("Received Logout has text (58) tag: {}", text.getValue());
+            String wrongClientSequence = StringUtils.substringBetween(text.getValue(), "expecting ", " but received");
+            if (wrongClientSequence != null) {
+                msgSeqNum.set(Integer.parseInt(wrongClientSequence) - 1);
+                isSequenceChanged = true;
+            }
+            String wrongClientNextExpectedSequence = StringUtils.substringBetween(text.getValue(), "MSN to be sent is ", " but received");
+            if(wrongClientNextExpectedSequence != null && settings.getResetStateOnServerReset()) {
+                serverMsgSeqNum.set(Integer.parseInt(wrongClientNextExpectedSequence));
             }
         }
 
@@ -514,7 +559,7 @@ private void resetSequence(ByteBuf message) {
                 serverMsgSeqNum.set(Integer.parseInt(requireNonNull(seqNumValue.getValue())) - 1);
             }
         } else {
-            LOGGER.trace("Failed to reset servers MsgSeqNum. No such tag in message: {}", message.toString(US_ASCII));
+            if(LOGGER.isWarnEnabled()) warn("Failed to reset servers MsgSeqNum. No such tag in message: %s", message.toString(US_ASCII));
         }
     }
 
@@ -522,7 +567,9 @@ private void reset() {
         msgSeqNum.set(0);
         serverMsgSeqNum.set(0);
         sessionActive.set(true);
-        messageLoader.updateTime();
+        if(messageLoader != null) {
+            messageLoader.updateTime();
+        }
         channel.open();
     }
 
@@ -579,7 +626,7 @@ private void recovery(int beginSeqNo, int endSeqNo) {
             }
 
             int endSeq = endSeqNo;
-            LOGGER.info("Loading messages from {} to {}", beginSeqNo, endSeqNo);
+            info("Loading messages from %d to %d", beginSeqNo, endSeqNo);
             if(settings.isLoadMissedMessagesFromCradle()) {
                 Function1<ByteBuf, Boolean> processMessage = (buf) -> {
                     FixField seqNum = findField(buf, MSG_SEQ_NUM_TAG);
@@ -641,7 +688,7 @@ private void recovery(int beginSeqNo, int endSeqNo) {
             resetHeartbeatTask();
 
         } catch (Exception e) {
-            LOGGER.error("Error while loading messages for recovery", e);
+            error("Error while loading messages for recovery", e);
             String seqReset =
                 createSequenceReset(Math.max(beginSeqNo, lastProcessedSequence.get() + 1), msgSeqNum.get() + 1).toString();
             channel.send(
@@ -698,9 +745,9 @@ private boolean checkLogon(ByteBuf message) {
     public void onOutgoing(@NotNull IChannel channel, @NotNull ByteBuf message, @NotNull Map<String, String> metadata) {
         onOutgoingUpdateTag(message, metadata);
 
-        if (LOGGER.isDebugEnabled()) {
-            LOGGER.debug("Outgoing message: {}", message.toString(US_ASCII));
-        }
+        if(LOGGER.isDebugEnabled()) debug("Outgoing message: %s", message.toString(US_ASCII));
+
+        if(enabled.get()) resetHeartbeatTask();
     }
 
     public void onOutgoingUpdateTag(@NotNull ByteBuf message, @NotNull Map<String, String> metadata) {
@@ -723,9 +770,7 @@ public void onOutgoingUpdateTag(@NotNull ByteBuf message, @NotNull Map<String, S
         FixField msgType = findField(message, MSG_TYPE_TAG, US_ASCII, bodyLength);
 
         if (msgType == null) {                                                        //should we interrupt sending message?
-            if (LOGGER.isErrorEnabled()) {
-                LOGGER.error("No msgType in message {}", message.toString(US_ASCII));
-            }
+            if(LOGGER.isErrorEnabled()) error("No msgType in message %s", null, message.toString(US_ASCII));
 
             if (metadata.get("MsgType") != null) {
                 msgType = bodyLength.insertNext(MSG_TYPE_TAG, metadata.get("MsgType"));
@@ -812,15 +857,20 @@ public void onOpen(@NotNull IChannel channel) {
         sendLogon();
     }
 
-    public void sendHeartbeat() {
+    public void sendHeartbeat() {sendHeartbeatTestReqId(null);}
+
+    private void sendHeartbeatTestReqId(String testReqId) {
         StringBuilder heartbeat = new StringBuilder();
         int seqNum = msgSeqNum.incrementAndGet();
 
         setHeader(heartbeat, MSG_TYPE_HEARTBEAT, seqNum, null);
+        if(testReqId != null) {
+            heartbeat.append(TEST_REQ_ID).append(testReqId);
+        }
         setChecksumAndBodyLength(heartbeat);
 
         if (enabled.get()) {
-            LOGGER.info("Send Heartbeat to server - {}", heartbeat);
+            info("Send Heartbeat to server - %s", heartbeat);
             channel.send(Unpooled.wrappedBuffer(heartbeat.toString().getBytes(StandardCharsets.UTF_8)), Collections.emptyMap(), null, IChannel.SendMode.MANGLE);
             resetHeartbeatTask();
 
@@ -836,7 +886,7 @@ public void sendTestRequest() { //do private
         setChecksumAndBodyLength(testRequest);
         if (enabled.get()) {
             channel.send(Unpooled.wrappedBuffer(testRequest.toString().getBytes(StandardCharsets.UTF_8)), Collections.emptyMap(), null, IChannel.SendMode.MANGLE);
-            LOGGER.info("Send TestRequest to server - {}", testRequest);
+            info("Send TestRequest to server - %s", testRequest);
             resetTestRequestTask();
             resetHeartbeatTask();
         } else {
@@ -847,13 +897,16 @@ public void sendTestRequest() { //do private
 
     public void sendLogon() {
         if(!sessionActive.get() || !channel.isOpen()) {
-            LOGGER.info("Logon is not sent to server because session is not active.");
+            info("Logon is not sent to server because session is not active.");
             return;
         }
         StringBuilder logon = new StringBuilder();
         Boolean reset;
-        if (!connStarted.get()) reset = settings.getResetSeqNumFlag();
-        else reset = settings.getResetOnLogon();
+        if (!connStarted.get()) {
+            reset = settings.getResetSeqNumFlag();
+        } else {
+            reset = settings.getResetOnLogon();
+        }
         if (reset) msgSeqNum.getAndSet(0);
 
         setHeader(logon, MSG_TYPE_LOGON, msgSeqNum.get() + 1, null);
@@ -879,17 +932,24 @@ public void sendLogon() {
         }
 
         setChecksumAndBodyLength(logon);
-        LOGGER.info("Send logon - {}", logon);
+        info("Send logon - %s", logon);
         channel.send(Unpooled.wrappedBuffer(logon.toString().getBytes(StandardCharsets.UTF_8)), Collections.emptyMap(), null, IChannel.SendMode.MANGLE);
     }
 
     private void sendLogout() {
+        sendLogout(null);
+    }
+
+    private void sendLogout(String text) {
         if (enabled.get()) {
             StringBuilder logout = new StringBuilder();
             setHeader(logout, MSG_TYPE_LOGOUT, msgSeqNum.incrementAndGet(), null);
+            if(text != null) {
+               logout.append(TEXT).append(text);
+            }
             setChecksumAndBodyLength(logout);
 
-            LOGGER.debug("Sending logout - {}", logout);
+            debug("Sending logout - %s", logout);
 
             try {
                 channel.send(
@@ -899,9 +959,9 @@ private void sendLogout() {
                         IChannel.SendMode.MANGLE
                 ).get();
 
-                LOGGER.info("Sent logout - {}", logout);
+                info("Sent logout - %s", logout);
             } catch (Exception e) {
-                LOGGER.error("Failed to send logout - {}", logout, e);
+                error("Failed to send logout - %s", e, logout);
             }
         }
     }
@@ -931,15 +991,25 @@ public void close() {
     private void waitLogoutResponse() {
         long start = System.currentTimeMillis();
         while(System.currentTimeMillis() - start < settings.getDisconnectRequestDelay() && enabled.get()) {
-            if (LOGGER.isWarnEnabled()) LOGGER.warn("Waiting session logout: {}", channel.getSessionAlias());
+            warn("Waiting session logout");
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
-                LOGGER.error("Error while sleeping.");
+                error("Error while sleeping.", null);
             }
         }
     }
 
+    private void disconnect(Boolean graceful) throws ExecutionException, InterruptedException {
+        if(graceful) {
+            sendLogout();
+            waitLogoutResponse();
+        }
+        resetHeartbeatTask();
+        resetTestRequestTask();
+        channel.close().get();
+    }
+
     private void setHeader(StringBuilder stringBuilder, String msgType, Integer seqNum, String time) {
         stringBuilder.append(BEGIN_STRING_TAG).append("=").append(settings.getBeginString());
         stringBuilder.append(MSG_TYPE).append(msgType);
@@ -1071,4 +1141,28 @@ private void resetTestRequestTask() {
     private void cancelFuture(AtomicReference<Future<?>> future) {
         future.get().cancel(false);
     }
+
+    private void info(String message, Object... args) {
+        if(LOGGER.isInfoEnabled()) {
+            LOGGER.info("{} - {}: {}", channel.getSessionGroup(), channel.getSessionAlias(), String.format(message, args));
+        }
+    }
+
+    private void error(String message, Throwable throwable, Object... args) {
+        if(LOGGER.isErrorEnabled()) {
+            LOGGER.error("{} - {}: {}", channel.getSessionGroup(), channel.getSessionAlias(), String.format(message, args), throwable);
+        }
+    }
+
+    private void warn(String message, Object... args) {
+        if(LOGGER.isWarnEnabled()) {
+            LOGGER.warn("{} - {}: {}", channel.getSessionGroup(), channel.getSessionAlias(), String.format(message, args));
+        }
+    }
+
+    private void debug(String message, Object... args) {
+        if(LOGGER.isDebugEnabled()) {
+            LOGGER.debug("{} - {}: {}", channel.getSessionGroup(), channel.getSessionAlias(), String.format(message, args));
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/com/exactpro/th2/FixHandlerSettings.java b/src/main/java/com/exactpro/th2/FixHandlerSettings.java
index 7f5c623..99a21ce 100644
--- a/src/main/java/com/exactpro/th2/FixHandlerSettings.java
+++ b/src/main/java/com/exactpro/th2/FixHandlerSettings.java
@@ -54,10 +54,10 @@ public class FixHandlerSettings implements IHandlerSettings {
     private Boolean resetSeqNumFlag = false;
     private Boolean resetOnLogon = false;
     private Boolean useNextExpectedSeqNum = false;
-    private Boolean saveAdminMessages = false;
     private Boolean loadSequencesFromCradle = false;
     private Boolean loadMissedMessagesFromCradle = false;
     private Boolean resetStateOnServerReset = false;
+    private Boolean logoutOnIncorrectServerSequence = false;
 
     @JsonDeserialize(using = LocalTimeDeserializer.class)
     private LocalTime sessionStartTime;
@@ -266,12 +266,12 @@ public void setUseNextExpectedSeqNum(Boolean useNextExpectedSeqNum) {
         this.useNextExpectedSeqNum = useNextExpectedSeqNum;
     }
 
-    public Boolean isSaveAdminMessages() {
-        return saveAdminMessages;
+    public Boolean isLogoutOnIncorrectServerSequence() {
+        return logoutOnIncorrectServerSequence;
     }
 
-    public void setSaveAdminMessages(Boolean saveAdminMessages) {
-        this.saveAdminMessages = saveAdminMessages;
+    public void setLogoutOnIncorrectServerSequence(Boolean logoutOnIncorrectServerSequence) {
+        this.logoutOnIncorrectServerSequence = logoutOnIncorrectServerSequence;
     }
 
     public LocalTime getSessionStartTime() {
diff --git a/src/main/java/com/exactpro/th2/constants/Constants.java b/src/main/java/com/exactpro/th2/constants/Constants.java
index 35252d7..de4beed 100644
--- a/src/main/java/com/exactpro/th2/constants/Constants.java
+++ b/src/main/java/com/exactpro/th2/constants/Constants.java
@@ -82,6 +82,7 @@ public class Constants {
     public static final String NEXT_EXPECTED_SEQ_NUM = SOH + NEXT_EXPECTED_SEQ_NUMBER_TAG + "=";
     public static final String POSS_DUP = SOH + POSS_DUP_TAG + "=";
     public static final String ORIG_SENDING_TIME = SOH + ORIG_SENDING_TIME_TAG + "=";
+    public static final String TEXT = SOH + TEXT_TAG + "=";
 
     //message types
     public static final String MSG_TYPE_LOGON = "A";
@@ -100,5 +101,6 @@ public class Constants {
     );
 
     public static final String IS_POSS_DUP = "Y";
+    public static final String IS_SEQUENCE_RESET_FLAG = "Y";
     public static final int SUCCESSFUL_LOGOUT_CODE = 4;
 }