diff --git a/services/tunnelbroker/src/Database/DatabaseManager.cpp b/services/tunnelbroker/src/Database/DatabaseManager.cpp
index 42d2228be..72a720d41 100644
--- a/services/tunnelbroker/src/Database/DatabaseManager.cpp
+++ b/services/tunnelbroker/src/Database/DatabaseManager.cpp
@@ -1,202 +1,206 @@
 #include "DatabaseManager.h"
 
 namespace comm {
 namespace network {
 namespace database {
 
 DatabaseManager &DatabaseManager::getInstance() {
   static DatabaseManager instance;
   return instance;
 }
 
 bool DatabaseManager::isTableAvailable(const std::string &tableName) {
   Aws::DynamoDB::Model::DescribeTableRequest request;
   request.SetTableName(tableName);
 
   // Check table availability by invoking DescribeTable
   const Aws::DynamoDB::Model::DescribeTableOutcome &result =
       getDynamoDBClient()->DescribeTable(request);
   return result.IsSuccess();
 }
 
 void DatabaseManager::innerPutItem(
     std::shared_ptr<Item> item,
     const Aws::DynamoDB::Model::PutItemRequest &request) {
   const Aws::DynamoDB::Model::PutItemOutcome outcome =
       getDynamoDBClient()->PutItem(request);
   if (!outcome.IsSuccess()) {
     throw std::runtime_error(outcome.GetError().GetMessage());
   }
 }
 
 template <typename T>
 std::shared_ptr<T>
 DatabaseManager::innerFindItem(Aws::DynamoDB::Model::GetItemRequest &request) {
   std::shared_ptr<T> item = createItemByType<T>();
   request.SetTableName(item->getTableName());
   const Aws::DynamoDB::Model::GetItemOutcome &outcome =
       getDynamoDBClient()->GetItem(request);
   if (!outcome.IsSuccess()) {
     throw std::runtime_error(outcome.GetError().GetMessage());
   }
   const AttributeValues &outcomeItem = outcome.GetResult().GetItem();
   if (!outcomeItem.size()) {
     return nullptr;
   }
   item->assignItemFromDatabase(outcomeItem);
   return std::move(item);
 }
 
 void DatabaseManager::innerRemoveItem(
     const Item &item,
     const std::string &key) {
   Aws::DynamoDB::Model::DeleteItemRequest request;
   request.SetTableName(item.getTableName());
   request.AddKey(
       item.getPrimaryKey(), Aws::DynamoDB::Model::AttributeValue(key));
 
   const Aws::DynamoDB::Model::DeleteItemOutcome &outcome =
       getDynamoDBClient()->DeleteItem(request);
   if (!outcome.IsSuccess()) {
     throw std::runtime_error(outcome.GetError().GetMessage());
   }
 }
 
 void DatabaseManager::putSessionItem(const DeviceSessionItem &item) {
   Aws::DynamoDB::Model::PutItemRequest request;
   request.SetTableName(item.getTableName());
   request.AddItem(
       DeviceSessionItem::FIELD_SESSION_ID,
       Aws::DynamoDB::Model::AttributeValue(item.getSessionID()));
   request.AddItem(
       DeviceSessionItem::FIELD_DEVICE_ID,
       Aws::DynamoDB::Model::AttributeValue(item.getDeviceID()));
   request.AddItem(
       DeviceSessionItem::FIELD_PUBKEY,
       Aws::DynamoDB::Model::AttributeValue(item.getPubKey()));
   request.AddItem(
       DeviceSessionItem::FIELD_NOTIFY_TOKEN,
       Aws::DynamoDB::Model::AttributeValue(item.getNotifyToken()));
   request.AddItem(
       DeviceSessionItem::FIELD_DEVICE_TYPE,
       Aws::DynamoDB::Model::AttributeValue(item.getDeviceType()));
   request.AddItem(
       DeviceSessionItem::FIELD_APP_VERSION,
       Aws::DynamoDB::Model::AttributeValue(item.getAppVersion()));
   request.AddItem(
       DeviceSessionItem::FIELD_DEVICE_OS,
       Aws::DynamoDB::Model::AttributeValue(item.getDeviceOs()));
   request.AddItem(
       DeviceSessionItem::FIELD_CHECKPOINT_TIME,
       Aws::DynamoDB::Model::AttributeValue(
           std::to_string(item.getCheckpointTime())));
   request.AddItem(
       DeviceSessionItem::FIELD_EXPIRE,
       Aws::DynamoDB::Model::AttributeValue(std::to_string(
           static_cast<size_t>(std::time(0)) + SESSION_RECORD_TTL)));
   this->innerPutItem(std::make_shared<DeviceSessionItem>(item), request);
 }
 
 std::shared_ptr<DeviceSessionItem>
 DatabaseManager::findSessionItem(const std::string &sessionID) {
   Aws::DynamoDB::Model::GetItemRequest request;
   request.AddKey(
       DeviceSessionItem::FIELD_SESSION_ID,
       Aws::DynamoDB::Model::AttributeValue(sessionID));
   return std::move(this->innerFindItem<DeviceSessionItem>(request));
 }
 
+void DatabaseManager::removeSessionItem(const std::string &sessionID) {
+  this->innerRemoveItem(*(createItemByType<DeviceSessionItem>()), sessionID);
+}
+
 void DatabaseManager::putSessionSignItem(const SessionSignItem &item) {
   Aws::DynamoDB::Model::PutItemRequest request;
   request.SetTableName(item.getTableName());
   request.AddItem(
       SessionSignItem::FIELD_SESSION_VERIFICATION,
       Aws::DynamoDB::Model::AttributeValue(item.getSign()));
   request.AddItem(
       SessionSignItem::FIELD_DEVICE_ID,
       Aws::DynamoDB::Model::AttributeValue(item.getDeviceID()));
   request.AddItem(
       SessionSignItem::FIELD_EXPIRE,
       Aws::DynamoDB::Model::AttributeValue(std::to_string(
           static_cast<size_t>(std::time(0)) + SESSION_SIGN_RECORD_TTL)));
   this->innerPutItem(std::make_shared<SessionSignItem>(item), request);
 }
 
 std::shared_ptr<SessionSignItem>
 DatabaseManager::findSessionSignItem(const std::string &deviceID) {
   Aws::DynamoDB::Model::GetItemRequest request;
   request.AddKey(
       SessionSignItem::FIELD_DEVICE_ID,
       Aws::DynamoDB::Model::AttributeValue(deviceID));
   return std::move(this->innerFindItem<SessionSignItem>(request));
 }
 
 void DatabaseManager::removeSessionSignItem(const std::string &deviceID) {
   this->innerRemoveItem(*(createItemByType<SessionSignItem>()), deviceID);
 }
 
 void DatabaseManager::putPublicKeyItem(const PublicKeyItem &item) {
   Aws::DynamoDB::Model::PutItemRequest request;
   request.SetTableName(item.getTableName());
   request.AddItem(
       PublicKeyItem::FIELD_DEVICE_ID,
       Aws::DynamoDB::Model::AttributeValue(item.getDeviceID()));
   request.AddItem(
       PublicKeyItem::FIELD_PUBLIC_KEY,
       Aws::DynamoDB::Model::AttributeValue(item.getPublicKey()));
   this->innerPutItem(std::make_shared<PublicKeyItem>(item), request);
 }
 
 std::shared_ptr<PublicKeyItem>
 DatabaseManager::findPublicKeyItem(const std::string &deviceID) {
   Aws::DynamoDB::Model::GetItemRequest request;
   request.AddKey(
       PublicKeyItem::FIELD_DEVICE_ID,
       Aws::DynamoDB::Model::AttributeValue(deviceID));
   return std::move(this->innerFindItem<PublicKeyItem>(request));
 }
 
 void DatabaseManager::removePublicKeyItem(const std::string &deviceID) {
   this->innerRemoveItem(*(createItemByType<PublicKeyItem>()), deviceID);
 }
 
 void DatabaseManager::putMessageItem(const MessageItem &item) {
   Aws::DynamoDB::Model::PutItemRequest request;
   request.SetTableName(item.getTableName());
   request.AddItem(
       MessageItem::FIELD_MESSAGE_ID,
       Aws::DynamoDB::Model::AttributeValue(item.getMessageID()));
   request.AddItem(
       MessageItem::FIELD_FROM_DEVICE_ID,
       Aws::DynamoDB::Model::AttributeValue(item.getFromDeviceID()));
   request.AddItem(
       MessageItem::FIELD_TO_DEVICE_ID,
       Aws::DynamoDB::Model::AttributeValue(item.getToDeviceID()));
   request.AddItem(
       MessageItem::FIELD_PAYLOAD,
       Aws::DynamoDB::Model::AttributeValue(item.getPayload()));
   request.AddItem(
       MessageItem::FIELD_BLOB_HASHES,
       Aws::DynamoDB::Model::AttributeValue(item.getBlobHashes()));
   request.AddItem(
       MessageItem::FIELD_EXPIRE,
       Aws::DynamoDB::Model::AttributeValue(std::to_string(item.getExpire())));
   this->innerPutItem(std::make_shared<MessageItem>(item), request);
 }
 
 std::shared_ptr<MessageItem>
 DatabaseManager::findMessageItem(const std::string &messageID) {
   Aws::DynamoDB::Model::GetItemRequest request;
   request.AddKey(
       MessageItem::FIELD_MESSAGE_ID,
       Aws::DynamoDB::Model::AttributeValue(messageID));
   return std::move(this->innerFindItem<MessageItem>(request));
 }
 
 void DatabaseManager::removeMessageItem(const std::string &messageID) {
   this->innerRemoveItem(*(createItemByType<MessageItem>()), messageID);
 }
 
 } // namespace database
 } // namespace network
 } // namespace comm
diff --git a/services/tunnelbroker/src/Database/DatabaseManager.h b/services/tunnelbroker/src/Database/DatabaseManager.h
index a68a377eb..a82156f83 100644
--- a/services/tunnelbroker/src/Database/DatabaseManager.h
+++ b/services/tunnelbroker/src/Database/DatabaseManager.h
@@ -1,58 +1,59 @@
 #pragma once
 
 #include "AwsTools.h"
 #include "Constants.h"
 #include "DatabaseEntitiesTools.h"
 #include "Tools.h"
 
 #include <aws/core/Aws.h>
 #include <aws/core/utils/Outcome.h>
 #include <aws/dynamodb/model/AttributeDefinition.h>
 #include <aws/dynamodb/model/DeleteItemRequest.h>
 #include <aws/dynamodb/model/DescribeTableRequest.h>
 #include <aws/dynamodb/model/DescribeTableResult.h>
 #include <aws/dynamodb/model/GetItemRequest.h>
 #include <aws/dynamodb/model/PutItemRequest.h>
 
 #include <memory>
 #include <string>
 
 namespace comm {
 namespace network {
 namespace database {
 
 class DatabaseManager {
 
   void innerPutItem(
       std::shared_ptr<Item> item,
       const Aws::DynamoDB::Model::PutItemRequest &request);
   template <typename T>
   std::shared_ptr<T>
   innerFindItem(Aws::DynamoDB::Model::GetItemRequest &request);
   void innerRemoveItem(const Item &item, const std::string &key);
 
 public:
   static DatabaseManager &getInstance();
   bool isTableAvailable(const std::string &tableName);
 
   void putSessionItem(const DeviceSessionItem &item);
   std::shared_ptr<DeviceSessionItem>
   findSessionItem(const std::string &deviceID);
+  void removeSessionItem(const std::string &sessionID);
 
   void putSessionSignItem(const SessionSignItem &item);
   std::shared_ptr<SessionSignItem>
   findSessionSignItem(const std::string &deviceID);
   void removeSessionSignItem(const std::string &deviceID);
 
   void putPublicKeyItem(const PublicKeyItem &item);
   std::shared_ptr<PublicKeyItem> findPublicKeyItem(const std::string &deviceID);
   void removePublicKeyItem(const std::string &deviceID);
 
   void putMessageItem(const MessageItem &item);
   std::shared_ptr<MessageItem> findMessageItem(const std::string &messageID);
   void removeMessageItem(const std::string &messageID);
 };
 
 } // namespace database
 } // namespace network
 } // namespace comm