diff --git a/services/tunnelbroker/docker-server/contents/server/src/Service/TunnelbrokerServiceImpl.cpp b/services/tunnelbroker/docker-server/contents/server/src/Service/TunnelbrokerServiceImpl.cpp
index 282d43bde..d41480770 100644
--- a/services/tunnelbroker/docker-server/contents/server/src/Service/TunnelbrokerServiceImpl.cpp
+++ b/services/tunnelbroker/docker-server/contents/server/src/Service/TunnelbrokerServiceImpl.cpp
@@ -1,226 +1,209 @@
 #include "TunnelbrokerServiceImpl.h"
 
 #include "AmqpManager.h"
 #include "AwsTools.h"
 #include "ConfigManager.h"
 #include "CryptoTools.h"
 #include "DatabaseManager.h"
 #include "DeliveryBroker.h"
 #include "Tools.h"
-
-#include <boost/lexical_cast.hpp>
-#include <boost/uuid/uuid.hpp>
-#include <boost/uuid/uuid_generators.hpp>
-#include <boost/uuid/uuid_io.hpp>
-
 namespace comm {
 namespace network {
 
 TunnelBrokerServiceImpl::TunnelBrokerServiceImpl() {
   Aws::InitAPI({});
   // List of AWS DynamoDB tables to check if they are created and can be
   // accessed before any AWS API methods
   const std::list<std::string> tablesList = {
       config::ConfigManager::getInstance().getParameter(
           config::ConfigManager::OPTION_DYNAMODB_SESSIONS_TABLE),
       config::ConfigManager::getInstance().getParameter(
           config::ConfigManager::OPTION_DYNAMODB_SESSIONS_VERIFICATION_TABLE),
       config::ConfigManager::getInstance().getParameter(
           config::ConfigManager::OPTION_DYNAMODB_SESSIONS_PUBLIC_KEY_TABLE)};
   for (const std::string &table : tablesList) {
     if (!database::DatabaseManager::getInstance().isTableAvailable(table)) {
       throw std::runtime_error(
           "Error: AWS DynamoDB table '" + table + "' is not available");
     }
   };
 };
 
 TunnelBrokerServiceImpl::~TunnelBrokerServiceImpl() {
   Aws::ShutdownAPI({});
 };
 
 grpc::Status TunnelBrokerServiceImpl::SessionSignature(
     grpc::ServerContext *context,
     const tunnelbroker::SessionSignatureRequest *request,
     tunnelbroker::SessionSignatureResponse *reply) {
   const std::string deviceID = request->deviceid();
   if (!validateDeviceID(deviceID)) {
     std::cout << "gRPC: "
               << "Format validation failed for " << deviceID << std::endl;
     return grpc::Status(
         grpc::StatusCode::INVALID_ARGUMENT,
         "Format validation failed for deviceID");
   }
   const std::string toSign = generateRandomString(SIGNATURE_REQUEST_LENGTH);
   std::shared_ptr<database::SessionSignItem> SessionSignItem =
       std::make_shared<database::SessionSignItem>(toSign, deviceID);
   database::DatabaseManager::getInstance().putSessionSignItem(*SessionSignItem);
   reply->set_tosign(toSign);
   return grpc::Status::OK;
 };
 
 grpc::Status TunnelBrokerServiceImpl::NewSession(
     grpc::ServerContext *context,
     const tunnelbroker::NewSessionRequest *request,
     tunnelbroker::NewSessionResponse *reply) {
 
   std::shared_ptr<database::DeviceSessionItem> deviceSessionItem;
   std::shared_ptr<database::SessionSignItem> sessionSignItem;
   std::shared_ptr<database::PublicKeyItem> publicKeyItem;
   const std::string deviceID = request->deviceid();
   if (!validateDeviceID(deviceID)) {
     std::cout << "gRPC: "
               << "Format validation failed for " << deviceID << std::endl;
     return grpc::Status(
         grpc::StatusCode::INVALID_ARGUMENT,
         "Format validation failed for deviceID");
   }
   const std::string signature = request->signature();
   const std::string publicKey = request->publickey();
-  const boost::uuids::uuid uuid = boost::uuids::random_generator()();
-  const std::string newSessionID = boost::lexical_cast<std::string>(uuid);
-
+  const std::string newSessionID = generateUUID();
   try {
-    deviceSessionItem =
-        database::DatabaseManager::getInstance().findSessionItem(newSessionID);
-    if (deviceSessionItem != nullptr) {
-      std::cout << "gRPC: "
-                << "Session unique ID " << newSessionID << " already used"
-                << std::endl;
-      return grpc::Status(
-          grpc::StatusCode::INTERNAL, "Session unique ID already used");
-    }
     sessionSignItem =
         database::DatabaseManager::getInstance().findSessionSignItem(deviceID);
     if (sessionSignItem == nullptr) {
       std::cout << "gRPC: "
                 << "Session sign request not found for deviceID: " << deviceID
                 << std::endl;
       return grpc::Status(
           grpc::StatusCode::NOT_FOUND, "Session sign request not found");
     }
     publicKeyItem =
         database::DatabaseManager::getInstance().findPublicKeyItem(deviceID);
     if (publicKeyItem == nullptr) {
       std::shared_ptr<database::PublicKeyItem> newPublicKeyItem =
           std::make_shared<database::PublicKeyItem>(deviceID, publicKey);
       database::DatabaseManager::getInstance().putPublicKeyItem(
           *newPublicKeyItem);
     } else if (publicKey != publicKeyItem->getPublicKey()) {
       std::cout << "gRPC: "
                 << "The public key doesn't match for deviceID" << std::endl;
       return grpc::Status(
           grpc::StatusCode::PERMISSION_DENIED,
           "The public key doesn't match for deviceID");
     }
     const std::string verificationMessage = sessionSignItem->getSign();
     if (!comm::network::crypto::rsaVerifyString(
             publicKey, verificationMessage, signature)) {
       std::cout << "gRPC: "
                 << "Signature for the verification message is not valid"
                 << std::endl;
       return grpc::Status(
           grpc::StatusCode::PERMISSION_DENIED,
           "Signature for the verification message is not valid");
     }
     database::DatabaseManager::getInstance().removeSessionSignItem(deviceID);
 
     deviceSessionItem = std::make_shared<database::DeviceSessionItem>(
         newSessionID,
         deviceID,
         request->publickey(),
         request->notifytoken(),
         tunnelbroker::NewSessionRequest_DeviceTypes_Name(request->devicetype()),
         request->deviceappversion(),
         request->deviceos());
     database::DatabaseManager::getInstance().putSessionItem(*deviceSessionItem);
   } catch (std::runtime_error &e) {
     std::cout << "gRPC: "
               << "Error while processing 'NewSession' request: " << e.what()
               << std::endl;
     return grpc::Status(grpc::StatusCode::INTERNAL, e.what());
   }
   reply->set_sessionid(newSessionID);
   return grpc::Status::OK;
 };
 
 grpc::Status TunnelBrokerServiceImpl::Send(
     grpc::ServerContext *context,
     const tunnelbroker::SendRequest *request,
     google::protobuf::Empty *reply) {
   try {
     const std::string sessionID = request->sessionid();
     std::shared_ptr<database::DeviceSessionItem> sessionItem =
         database::DatabaseManager::getInstance().findSessionItem(sessionID);
     if (sessionItem == nullptr) {
       std::cout << "gRPC: "
                 << "Session " << sessionID << " not found" << std::endl;
       return grpc::Status(
           grpc::StatusCode::PERMISSION_DENIED,
           "No such session found. SessionID: " + sessionID);
     }
     const std::string clientDeviceID = sessionItem->getDeviceID();
     if (!AMQPSend(
             request->todeviceid(),
             clientDeviceID,
             std::string(request->payload()))) {
       std::cout << "gRPC: "
                 << "Error while publish the message to AMQP" << std::endl;
       return grpc::Status(
           grpc::StatusCode::INTERNAL,
           "Error while publish the message to AMQP");
     }
   } catch (std::runtime_error &e) {
     std::cout << "gRPC: "
               << "Error while processing 'Send' request: " << e.what()
               << std::endl;
     return grpc::Status(grpc::StatusCode::INTERNAL, e.what());
   }
   return grpc::Status::OK;
 };
 
 grpc::Status TunnelBrokerServiceImpl::Get(
     grpc::ServerContext *context,
     const tunnelbroker::GetRequest *request,
     grpc::ServerWriter<tunnelbroker::GetResponse> *writer) {
   try {
     const std::string sessionID = request->sessionid();
     std::shared_ptr<database::DeviceSessionItem> sessionItem =
         database::DatabaseManager::getInstance().findSessionItem(sessionID);
     if (sessionItem == nullptr) {
       std::cout << "gRPC: "
                 << "Session " << sessionID << " not found" << std::endl;
       return grpc::Status(
           grpc::StatusCode::PERMISSION_DENIED,
           "No such session found. SessionID: " + sessionID);
     }
     const std::string clientDeviceID = sessionItem->getDeviceID();
     std::vector<DeliveryBrokerMessage> messagesToDeliver;
     while (1) {
       messagesToDeliver = DeliveryBroker::getInstance().get(clientDeviceID);
       for (auto const &message : messagesToDeliver) {
         tunnelbroker::GetResponse response;
         response.set_fromdeviceid(message.fromDeviceID);
         response.set_payload(message.payload);
         if (!writer->Write(response)) {
           throw std::runtime_error(
               "gRPC: 'Get' writer error on sending data to the client");
         }
         AMQPAck(message.deliveryTag);
       }
       if (!DeliveryBroker::getInstance().isEmpty(clientDeviceID)) {
         DeliveryBroker::getInstance().remove(clientDeviceID);
       }
       DeliveryBroker::getInstance().wait(clientDeviceID);
     }
   } catch (std::runtime_error &e) {
     std::cout << "gRPC: "
               << "Error while processing 'Get' request: " << e.what()
               << std::endl;
     return grpc::Status(grpc::StatusCode::INTERNAL, e.what());
   }
   return grpc::Status::OK;
 };
 
 } // namespace network
 } // namespace comm
diff --git a/services/tunnelbroker/docker-server/contents/server/src/Tools/Tools.cpp b/services/tunnelbroker/docker-server/contents/server/src/Tools/Tools.cpp
index 390fb5352..4d4bd36b0 100644
--- a/services/tunnelbroker/docker-server/contents/server/src/Tools/Tools.cpp
+++ b/services/tunnelbroker/docker-server/contents/server/src/Tools/Tools.cpp
@@ -1,50 +1,60 @@
 #include "Tools.h"
 #include "ConfigManager.h"
 #include "Constants.h"
 
+#include <boost/lexical_cast.hpp>
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+#include <boost/uuid/uuid_io.hpp>
+
 #include <chrono>
 #include <iostream>
+#include <random>
 #include <regex>
 
 namespace comm {
 namespace network {
 
 std::string generateRandomString(std::size_t length) {
   const std::string CHARACTERS =
       "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-  std::random_device random_device;
-  std::mt19937 generator(random_device());
+  thread_local std::random_device generator;
   std::uniform_int_distribution<> distribution(0, CHARACTERS.size() - 1);
   std::string random_string;
   for (std::size_t i = 0; i < length; ++i) {
     random_string += CHARACTERS[distribution(generator)];
   }
   return random_string;
 }
 
 long long getCurrentTimestamp() {
   using namespace std::chrono;
   return duration_cast<milliseconds>(system_clock::now().time_since_epoch())
       .count();
 }
 
 bool validateDeviceID(std::string deviceID) {
   try {
     static const std::regex deviceIDKeyserverRegexp("^ks:.*");
     if (std::regex_match(deviceID, deviceIDKeyserverRegexp)) {
       return (
           deviceID ==
           config::ConfigManager::getInstance().getParameter(
               config::ConfigManager::OPTION_DEFAULT_KEYSERVER_ID));
     }
     return std::regex_match(deviceID, DEVICEID_FORMAT_REGEX);
   } catch (const std::exception &e) {
     std::cout << "Tools: "
               << "Got an exception at `validateDeviceID`: " << e.what()
               << std::endl;
     return false;
   }
 }
 
+std::string generateUUID() {
+  thread_local boost::uuids::random_generator random_generator;
+  return boost::uuids::to_string(random_generator());
+}
+
 } // namespace network
 } // namespace comm
diff --git a/services/tunnelbroker/docker-server/contents/server/src/Tools/Tools.h b/services/tunnelbroker/docker-server/contents/server/src/Tools/Tools.h
index 65beb61d4..af50dc3d7 100644
--- a/services/tunnelbroker/docker-server/contents/server/src/Tools/Tools.h
+++ b/services/tunnelbroker/docker-server/contents/server/src/Tools/Tools.h
@@ -1,14 +1,15 @@
 #pragma once
 
 #include <random>
 #include <string>
 
 namespace comm {
 namespace network {
 
 std::string generateRandomString(std::size_t length);
 long long getCurrentTimestamp();
 bool validateDeviceID(std::string deviceID);
+std::string generateUUID();
 
 } // namespace network
 } // namespace comm