diff --git a/README.md b/README.md
index 36dedee..e151339 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@ After including TUD to your project you can implement the server like this:
 ```
 
 ```cpp
-auto serverDiscovery = std::make_shared<ServerDiscovery>(interface, 4000, 4001);
+auto serverDiscovery = std::make_shared<tud::ServerDiscovery>(interface, 4000, 4001, "yourNewIdenifier");
 std::thread serverDiscoveryThread([serverDiscovery]() {
   serverDiscovery->discoveryCycle();
 });
@@ -19,7 +19,7 @@ And the client like this:
 ```
 
 ```cpp
-auto clientDiscovery = std::make_shared<ClientDiscovery>(interface, 4000, 4001);
+auto clientDiscovery = std::make_shared<tud::ClientDiscovery>(interface, 4000, 4001, "yourNewIdenifier");
 std::thread clientDiscoveryThread([clientDiscovery]() {
   clientDiscovery->discoveryCycle();
 });
@@ -28,10 +28,11 @@ Both constructors want:
 1. your internet interface (string)
 2. your in port (int)
 3. your out port (int)
+4. your identifier (optional string)
 
 Then you can use it with these functions:
 ```cpp
-std::vector<std::string> getDiscoveredAdresses();
+std::vector<std::string> getDiscoveredAddresses();
 void removeDiscoveredAddress(std::string address);
 
 std::string getLocalIpAddress(std::string interface);
diff --git a/flake.lock b/flake.lock
index 1022845..a794f74 100644
--- a/flake.lock
+++ b/flake.lock
@@ -16,9 +16,44 @@
         "type": "github"
       }
     },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1784356753,
+        "narHash": "sha256-12KrbMiWLcf8m7pCvAtZh1ZrgF85ZXDXvfR/fWTKy84=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "61b7c44c4073f0b827768aff0049561b5110ea5a",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
     "root": {
       "inputs": {
-        "nixpkgs": "nixpkgs"
+        "nixpkgs": "nixpkgs",
+        "tablog": "tablog"
+      }
+    },
+    "tablog": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_2"
+      },
+      "locked": {
+        "lastModified": 1784813121,
+        "narHash": "sha256-ixwsmElsnlQE0MHPjS6m5+XmS47bFPHBYtZIxCTwLB8=",
+        "owner": "Sobottasgithub",
+        "repo": "tablog",
+        "rev": "e47b0796e6a0820315a846fb02a9c9c89b5bda33",
+        "type": "github"
+      },
+      "original": {
+        "owner": "Sobottasgithub",
+        "repo": "tablog",
+        "type": "github"
       }
     }
   },
diff --git a/flake.nix b/flake.nix
index 4ca150f..52f2505 100644
--- a/flake.nix
+++ b/flake.nix
@@ -3,21 +3,32 @@
 
   inputs = {
     nixpkgs.url = "github:nixos/nixpkgs?ref=nixos-unstable";
+
+    tablog = {
+      url = "github:Sobottasgithub/tablog";
+    };
   };
 
   outputs =
-    { self, nixpkgs }:
+    {
+      self,
+      nixpkgs,
+      tablog,
+    }:
     let
       system = "x86_64-linux";
       pkgs = import nixpkgs { inherit system; };
 
-      version = "0.1";
+      version = "0.8.0";
+
+      libtablog = tablog.packages.${system}.lib;
 
       commonDeps = with pkgs; [
         cmake
         gcc
         gnumake
         libtasn1
+        libtablog
       ];
 
       mkTUDPackage =
@@ -66,7 +77,7 @@
           };
         in
         {
-          inherit lib;
+          inherit lib libtablog;
 
           client = mkTUDPackage {
             pname = "tud-client";
diff --git a/lib/tud/CMakeLists.txt b/lib/tud/CMakeLists.txt
index d02a99f..ea2b844 100644
--- a/lib/tud/CMakeLists.txt
+++ b/lib/tud/CMakeLists.txt
@@ -15,5 +15,7 @@ target_include_directories(tud PUBLIC
     ${CMAKE_CURRENT_SOURCE_DIR}/include
 )
 
+target_link_libraries(tud PRIVATE tablog)
+
 install(TARGETS tud DESTINATION lib)
 install(DIRECTORY include/ DESTINATION include)
diff --git a/lib/tud/include/client_discovery.h b/lib/tud/include/client_discovery.h
index c12f05b..416b5dd 100644
--- a/lib/tud/include/client_discovery.h
+++ b/lib/tud/include/client_discovery.h
@@ -4,12 +4,14 @@
 #include "networking.h"
 
 #include <string>
+#include <optional>
 
-class ClientDiscovery: public Networking
-{
-    public:
-      ClientDiscovery(std::string interface, int inPort, int outPort);
-      void discoveryCycle();
-};
-
+namespace tud {
+  class ClientDiscovery: public Networking
+  {
+      public:
+        ClientDiscovery(std::string interface, int inPort, int outPort, std::optional<std::string> identifier);
+        void discoveryCycle();
+  };
+}
 #endif
diff --git a/lib/tud/include/networking.h b/lib/tud/include/networking.h
index da515ce..0ac6018 100644
--- a/lib/tud/include/networking.h
+++ b/lib/tud/include/networking.h
@@ -1,30 +1,44 @@
-#ifndef NETWORKING_H
-#define NETWORKING_H
+#ifndef Networking_H
+#define Networking_H
+
+#include <tablog.h>
 
 #include <string>
 #include <netinet/in.h>
 #include <vector>
 #include <mutex>
+#include <memory>
 
-class Networking
-{
-    public:
-        std::vector<std::string> getDiscoveredAdresses();
-        void removeDiscoveredAddress(std::string address);
+namespace tud {
+    class Networking
+    {
+        public:
+            std::vector<std::string> getDiscoveredAddresses();
+            void removeDiscoveredAddress(std::string address);
 
-        std::string getLocalIpAddress(std::string interface);
-        std::string getBroadcastIpAddress();
-        bool isValidIpV4(std::string &ipString);
+            std::string getLocalIpAddress(std::string interface);
+            std::string getBroadcastIpAddress();
+            bool isValidIpV4(std::string &ipString);
         
-    protected:
-        int sendMessageTo(int socket, const sockaddr_in& broadcast, std::string payload);
-        std::string receiveMessage(int socket);
+        protected:
+            std::shared_ptr<tablog::Tablog> logger;
+            
+            int sendMessageTo(int socket, const sockaddr_in& broadcast, std::string payload);
+            std::string receiveMessage(int socket);
+
+            bool hasSameIdentifier(std::string ipString);
+            std::string stripIdentifier(std::string ipString);
+
+            std::vector<std::string> discoveredAddresses = {};
+            std::mutex mtx;
+            std::string containerIP;
+            int inPort;
+            int outPort;
 
-        std::vector<std::string> discoveredAddresses = {};
-        std::mutex mtx;
-        std::string containerIP;
-        int inPort;
-        int outPort;
-};
+            std::string identifier = "tud";
 
+        private:
+            std::string identifierEscapeRegex(const std::string& text);
+    };
+}
 #endif
diff --git a/lib/tud/include/server_discovery.h b/lib/tud/include/server_discovery.h
index cfab448..cd51b85 100644
--- a/lib/tud/include/server_discovery.h
+++ b/lib/tud/include/server_discovery.h
@@ -4,18 +4,21 @@
 #include "networking.h"
 
 #include <string>
+#include <optional>
 
-class ServerDiscovery: public Networking
-{
-    public:
-      ServerDiscovery(std::string interface, int inPort, int outPort);
-      void discoveryCycle();
+namespace tud {
+  class ServerDiscovery: public Networking
+  {
+      public:
+        ServerDiscovery(std::string interface, int inPort, int outPort, std::optional<std::string> identifier);
+        void discoveryCycle();
 
-    private:
-      std::string broadcastIP;
+      private:
+        std::string broadcastIP;
 
-      void receiveDiscoveredCycle();
+        void receiveDiscoveredCycle();
 
-};
+  };
+}
 
 #endif
diff --git a/lib/tud/src/client_discovery.cpp b/lib/tud/src/client_discovery.cpp
index 3a4f8a4..a707dcc 100644
--- a/lib/tud/src/client_discovery.cpp
+++ b/lib/tud/src/client_discovery.cpp
@@ -1,81 +1,102 @@
 #include "../include/client_discovery.h"
 
+#include <tablog_registry.h>
+#include <tablog.h>
+
 #include <iostream>
 #include <cstring>
 #include <arpa/inet.h>
 #include <algorithm>
+#include <optional>
+#include <memory>
 
-ClientDiscovery::ClientDiscovery(std::string interface, int inPort, int outPort) {
-    this->containerIP = getLocalIpAddress(interface);
+namespace tud {
+    ClientDiscovery::ClientDiscovery(std::string interface, int inPort, int outPort, std::optional<std::string> identifier) {
+        tablog::TablogRegistry* registry = &tablog::TablogRegistry::getInstance();
+        std::shared_ptr<tablog::Tablog> logger = std::make_shared<tablog::Tablog>();
+        logger->configure("ClientUdpDiscovery", true);
+        registry->registerLogger("ClientUdpDiscovery", logger);
+        this->logger = logger;
 
-    this->inPort = inPort;
-    this->outPort = outPort;
-}
+        this->containerIP = getLocalIpAddress(interface);
 
-void ClientDiscovery::discoveryCycle() {
-    // Udp receive Socket
-    int udpSocket;
-    const int port = this->inPort; 
-    char buffer[1024];
-    
-    udpSocket = socket(AF_INET, SOCK_DGRAM, 0);
-    if (udpSocket < 0) {
-        std::wcout << "Create socket failed!" << std::endl;
-        return;
+        this->inPort = inPort;
+        this->outPort = outPort;
+
+        if(identifier.has_value()) {
+            this->identifier = identifier.value();
+        }
     }
 
-    int broadcast = 1;
-    setsockopt(udpSocket, SOL_SOCKET, SO_BROADCAST, &broadcast, sizeof(broadcast));
+    void ClientDiscovery::discoveryCycle() {
+        // Udp receive Socket
+        int udpSocket;
+        const int port = this->inPort; 
+        char buffer[1024];
+    
+        udpSocket = socket(AF_INET, SOCK_DGRAM, 0);
+        if (udpSocket < 0) {
+            logger->log(tablog::ERROR, "Create socket failed!");
+            return;
+        }
 
-    sockaddr_in nodeAddress{};
-    nodeAddress.sin_family = AF_INET;
-    nodeAddress.sin_addr.s_addr = htonl(INADDR_ANY);
-    nodeAddress.sin_port = htons(port);
+        int broadcast = 1;
+        setsockopt(udpSocket, SOL_SOCKET, SO_BROADCAST, &broadcast, sizeof(broadcast));
 
-    if (bind(udpSocket, (struct sockaddr*)&nodeAddress, sizeof(nodeAddress)) < 0) {
-        std::wcout << "UDP Socket bind failed!" << std::endl;
-        return;
-    }
+        sockaddr_in nodeAddress{};
+        nodeAddress.sin_family = AF_INET;
+        nodeAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+        nodeAddress.sin_port = htons(port);
 
-    // UDP send socket
-    int udpSendSocket;
-    struct sockaddr_in serverAddress{}, receiverAddress{};
-    const int sendPort = this->outPort;
+        if (bind(udpSocket, (struct sockaddr*)&nodeAddress, sizeof(nodeAddress)) < 0) {
+            logger->log(tablog::ERROR, "UDP Socket bind failed!");
+            return;
+        }
 
-    // Create socket
-    if ((udpSendSocket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
-        std::wcout << "Failed to create Socket!" << std::endl;
-        return;
-    }
-    // Allow reuse
-    int reuse = 1;
-    if (setsockopt(udpSendSocket, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0) {
-        std::wcout << "Setsockopt failed!" << std::endl;
-        return;
-    }
+        // UDP send socket
+        int udpSendSocket;
+        struct sockaddr_in serverAddress{}, receiverAddress{};
+        const int sendPort = this->outPort;
+
+        // Create socket
+        if ((udpSendSocket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
+            logger->log(tablog::ERROR, "Failed to create Socket!");
+            return;
+        }
+        // Allow reuse
+        int reuse = 1;
+        if (setsockopt(udpSendSocket, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0) {
+            logger->log(tablog::ERROR, "Setsockopt failed!");
+            return;
+        }
     
-    while (true) {
-        // Get UDP Discovery packet
-        std::string masterIP = receiveMessage(udpSocket);
-        if (isValidIpV4(masterIP)) {
-            if(std::find(discoveredAddresses.begin(), discoveredAddresses.end(), masterIP) == discoveredAddresses.end()) {
-                discoveredAddresses.push_back(masterIP);
-            }
+        while (true) {
+            // Get UDP Discovery packet
+            std::string receivedMessage = receiveMessage(udpSocket);
+            if (hasSameIdentifier(receivedMessage)) {
+                std::string masterIP = stripIdentifier(receivedMessage);
+                if (isValidIpV4(masterIP)) {
+                    if(std::find(discoveredAddresses.begin(), discoveredAddresses.end(), masterIP) == discoveredAddresses.end()) {
+                        discoveredAddresses.push_back(masterIP);
+                    }
 
-            // clear garbage
-            memset(&serverAddress, 0, sizeof(serverAddress));
-            // prepare socket
-            serverAddress.sin_family = AF_INET;
-            serverAddress.sin_port = htons(sendPort);
+                    // clear garbage
+                    memset(&serverAddress, 0, sizeof(serverAddress));
+                    // prepare socket
+                    serverAddress.sin_family = AF_INET;
+                    serverAddress.sin_port = htons(sendPort);
 
-            if (inet_pton(AF_INET, masterIP.c_str(), &serverAddress.sin_addr) <= 0) {
-                std::wcout << "Invalid broadcast IP" << std::endl;
-                return;
-            }
-            
-            if (sendMessageTo(udpSendSocket, serverAddress, containerIP.c_str()) != 0) {
-                std::wcout << "Broadcast failed!" << std::endl;
-                return;
+                    if (inet_pton(AF_INET, masterIP.c_str(), &serverAddress.sin_addr) <= 0) {
+                        logger->log(tablog::ERROR, "Invalid broadcast IP");
+                        return;
+                    }
+
+                    std::string message = this->identifier + containerIP;
+                    if (sendMessageTo(udpSendSocket, serverAddress, message.c_str()) != 0) {
+                        logger->log(tablog::ERROR, "Broadcast failed!");
+                        return;
+                    }
+                }
             }
         }
     }
diff --git a/lib/tud/src/networking.cpp b/lib/tud/src/networking.cpp
index f8befca..99dbce0 100644
--- a/lib/tud/src/networking.cpp
+++ b/lib/tud/src/networking.cpp
@@ -1,5 +1,7 @@
 #include "../include/networking.h"
 
+#include <tablog.h>
+
 #include <iostream>
 #include <sys/poll.h>
 #include <netinet/in.h>
@@ -10,143 +12,165 @@
 #include <net/if.h>
 #include <sstream>
 #include <arpa/inet.h>
+#include <regex>
+#include <string>
+
+namespace tud {
+  int Networking::sendMessageTo(int socket, const sockaddr_in& broadcast, std::string payload) {
+    if (sendto(socket, payload.data(), payload.size(), 0, (struct sockaddr*)&broadcast, sizeof(broadcast)) < 0) {
+        logger->log(tablog::ERROR, "buffer: Sendto Failed!");
+        return -1;
+    }
 
-int Networking::sendMessageTo(int socket, const sockaddr_in& broadcast, std::string payload) {
-  if (sendto(socket, payload.data(), payload.size(), 0, (struct sockaddr*)&broadcast, sizeof(broadcast)) < 0) {
-      std::wcout << "buffer: Sendto Failed!" << std::endl;
-      return -1;
+    return 0;
   }
 
-  return 0;
-}
+  std::string Networking::receiveMessage(int socket) {
+    std::string data;
+    pollfd pfd{};
+    pfd.fd = socket;
+    pfd.events = POLLIN;
 
-std::string Networking::receiveMessage(int socket) {
-  std::string data;
-  pollfd pfd{};
-  pfd.fd = socket;
-  pfd.events = POLLIN;
+    int ret = poll(&pfd, 1, 10000);
 
-  int ret = poll(&pfd, 1, 10000);
-
-  int bufferSize = 1024;
-  if (ret > 0 && (pfd.revents & POLLIN)) {
-      char* buffer = new char[bufferSize];
-      ssize_t size = recv(socket, buffer, bufferSize, 0);
+    int bufferSize = 1024;
+    if (ret > 0 && (pfd.revents & POLLIN)) {
+        char* buffer = new char[bufferSize];
+        ssize_t size = recv(socket, buffer, bufferSize, 0);
       
-      data = buffer;
+        data = buffer;
     
-      if (size <= 0) return data;
-      return data;
+        if (size <= 0) return data;
+        return data;
+    }
+    return data;
   }
-  return data;
-}
 
-std::vector<std::string> Networking::getDiscoveredAdresses() {
-    std::lock_guard<std::mutex> lock(mtx);
-    return discoveredAddresses;
-}
+  std::vector<std::string> Networking::getDiscoveredAddresses() {
+      std::lock_guard<std::mutex> lock(mtx);
+      return discoveredAddresses;
+  }
 
-void Networking::removeDiscoveredAddress(std::string address) {
-    std::lock_guard<std::mutex> lock(mtx);
-    discoveredAddresses.erase(find(discoveredAddresses.begin(), discoveredAddresses.end(), address));
-}
+  void Networking::removeDiscoveredAddress(std::string address) {
+      std::lock_guard<std::mutex> lock(mtx);
+      discoveredAddresses.erase(find(discoveredAddresses.begin(), discoveredAddresses.end(), address));
+  }
 
-std::string Networking::getLocalIpAddress(std::string interface) {
-  struct ifaddrs *ifaddr = nullptr;
+  std::string Networking::getLocalIpAddress(std::string interface) {
+    struct ifaddrs *ifaddr = nullptr;
 
-  // Get linked list of network interfaces
-  if (getifaddrs(&ifaddr) == -1) {
-    return "";
-  }
+    // Get linked list of network interfaces
+    if (getifaddrs(&ifaddr) == -1) {
+      return "";
+    }
 
-  std::string result;
+    std::string result;
 
-  // Iterate through interfaces
-  for (auto *ifa = ifaddr; ifa != nullptr; ifa = ifa->ifa_next) {
-    if (!ifa->ifa_addr)
-      continue;
+    // Iterate through interfaces
+    for (auto *ifa = ifaddr; ifa != nullptr; ifa = ifa->ifa_next) {
+      if (!ifa->ifa_addr)
+        continue;
 
-    if (ifa->ifa_addr->sa_family == AF_INET) {
-      auto *addr = reinterpret_cast<struct sockaddr_in *>(ifa->ifa_addr);
-      char ip[INET_ADDRSTRLEN];
-      inet_ntop(AF_INET, &addr->sin_addr, ip, sizeof(ip));
+      if (ifa->ifa_addr->sa_family == AF_INET) {
+        auto *addr = reinterpret_cast<struct sockaddr_in *>(ifa->ifa_addr);
+        char ip[INET_ADDRSTRLEN];
+        inet_ntop(AF_INET, &addr->sin_addr, ip, sizeof(ip));
 
-      // Docker containers typically use eth0
-      if (std::string(ifa->ifa_name) == interface) {
-        result = ip;
-        break;
+        // Docker containers typically use eth0
+        if (std::string(ifa->ifa_name) == interface) {
+          result = ip;
+          break;
+        }
       }
     }
-  }
-
-  freeifaddrs(ifaddr);
-  return result;
-}
 
-std::string Networking::getBroadcastIpAddress() {
-  struct ifaddrs *ifaddr = nullptr;
-  std::string broadcastIP;
-
-  // Get network interfaces
-  if (getifaddrs(&ifaddr) == -1) {
-    return "";
+    freeifaddrs(ifaddr);
+    return result;
   }
 
-  for (struct ifaddrs *ifa = ifaddr; ifa != nullptr; ifa = ifa->ifa_next) {
-    if (ifa->ifa_addr == nullptr)
-      continue;
+  std::string Networking::getBroadcastIpAddress() {
+    struct ifaddrs *ifaddr = nullptr;
+    std::string broadcastIP;
 
-    // Only consider IPv4 interfaces that are up and support broadcast
-    if (ifa->ifa_addr->sa_family == AF_INET &&
-        (ifa->ifa_flags & IFF_BROADCAST) && (ifa->ifa_flags & IFF_UP) &&
-        !(ifa->ifa_flags & IFF_LOOPBACK)) {
+    // Get network interfaces
+    if (getifaddrs(&ifaddr) == -1) {
+      return "";
+    }
 
-      // Ensure the broadcast address exists
-      if (ifa->ifa_broadaddr) {
-        struct sockaddr_in *bcast =
-            reinterpret_cast<struct sockaddr_in *>(ifa->ifa_broadaddr);
-        char ip[INET_ADDRSTRLEN];
-        if (inet_ntop(AF_INET, &(bcast->sin_addr), ip, INET_ADDRSTRLEN)) {
-          broadcastIP = ip;
-          break; // stop at the first valid one
+    for (struct ifaddrs *ifa = ifaddr; ifa != nullptr; ifa = ifa->ifa_next) {
+      if (ifa->ifa_addr == nullptr)
+        continue;
+
+      // Only consider IPv4 interfaces that are up and support broadcast
+      if (ifa->ifa_addr->sa_family == AF_INET &&
+          (ifa->ifa_flags & IFF_BROADCAST) && (ifa->ifa_flags & IFF_UP) &&
+          !(ifa->ifa_flags & IFF_LOOPBACK)) {
+
+        // Ensure the broadcast address exists
+        if (ifa->ifa_broadaddr) {
+          struct sockaddr_in *bcast =
+              reinterpret_cast<struct sockaddr_in *>(ifa->ifa_broadaddr);
+          char ip[INET_ADDRSTRLEN];
+          if (inet_ntop(AF_INET, &(bcast->sin_addr), ip, INET_ADDRSTRLEN)) {
+            broadcastIP = ip;
+            break; // stop at the first valid one
+          }
         }
       }
     }
+
+    freeifaddrs(ifaddr);
+    return broadcastIP;
   }
 
-  freeifaddrs(ifaddr);
-  return broadcastIP;
-}
+  bool Networking::isValidIpV4(std::string &ipString) {
+    if (ipString.size() < 7)
+      return false;
 
-bool Networking::isValidIpV4(std::string &ipString) {
-  if (ipString.size() < 7)
-    return false;
+    int count = 0;
+    // Seperate Ip Octets
+    std::stringstream stringStream(ipString);
+    while (stringStream.good()) {
+      std::string octet;
+      getline(stringStream, octet, '.');
 
-  int count = 0;
-  // Seperate Ip Octets
-  std::stringstream stringStream(ipString);
-  while (stringStream.good()) {
-    std::string octet;
-    getline(stringStream, octet, '.');
+      if (octet.size() > 1) {
+        if (octet[0] == '0')
+          return false;
+      }
 
-    if (octet.size() > 1) {
-      if (octet[0] == '0')
-        return false;
-    }
+      for (int index = 0; index < octet.size(); index++) {
+        if (isalpha(octet[index]))
+          return false;
+      }
 
-    for (int index = 0; index < octet.size(); index++) {
-      if (isalpha(octet[index]))
+      if (stoi(octet) > 255)
         return false;
+
+      count++;
     }
 
-    if (stoi(octet) > 255)
+    if (count != 4)
       return false;
 
-    count++;
+    return true;
+  }
+
+  bool Networking::hasSameIdentifier(std::string ipString) {
+    std::string identifierPattern = "^" + identifierEscapeRegex(this->identifier);
+    std::regex pattern(identifierPattern);
+    return std::regex_search(ipString, pattern);
   }
 
-  if (count != 4)
-    return false;
+  std::string Networking::stripIdentifier(std::string ipString) {
+    std::string identifierPattern = "^" + identifierEscapeRegex(this->identifier);
+    std::regex pattern(identifierPattern);
+
+    return std::regex_replace(ipString, pattern, "");
+  }
 
-  return true;
+  std::string Networking::identifierEscapeRegex(const std::string& identifier) {
+      static const std::regex special_chars(R"([-[\]{}()*+?.,\^$|#\s])");
+      return std::regex_replace(identifier, special_chars, R"(\$&)");
+  }
 }
diff --git a/lib/tud/src/server_discovery.cpp b/lib/tud/src/server_discovery.cpp
index 2c74adc..7be9b67 100644
--- a/lib/tud/src/server_discovery.cpp
+++ b/lib/tud/src/server_discovery.cpp
@@ -1,100 +1,120 @@
 #include "../include/server_discovery.h"
 
+#include <tablog_registry.h>
+#include <tablog.h>
+
 #include <iostream>
 #include <unistd.h>
 #include <cstring>
 #include <arpa/inet.h>
 #include <thread>
 #include <algorithm>
+#include <optional>
+#include <memory>
 
-ServerDiscovery::ServerDiscovery(std::string interface, int inPort, int outPort) {
-    this->containerIP = getLocalIpAddress(interface);
-    this->broadcastIP = getBroadcastIpAddress();
+namespace tud {
+    ServerDiscovery::ServerDiscovery(std::string interface, int inPort, int outPort, std::optional<std::string> identifier) {
+        tablog::TablogRegistry* registry = &tablog::TablogRegistry::getInstance();
+        std::shared_ptr<tablog::Tablog> logger = std::make_shared<tablog::Tablog>();
+        logger->configure("ServerUdpDiscovery", true);
+        registry->registerLogger("ServerUdpDiscovery", logger);
+        this->logger = logger;
 
-    this->inPort = inPort;
-    this->outPort = outPort;
-}
+        this->containerIP = getLocalIpAddress(interface);
+        this->broadcastIP = getBroadcastIpAddress();
 
-void ServerDiscovery::discoveryCycle() {
-    std::thread receiveDiscoveredCycleThread([this]() {
-        receiveDiscoveredCycle();
-    });
-    
-    int serverSocket;
-    struct sockaddr_in broadcast{}, receiverAddress{};
-    const int port = this->inPort;
-
-    // Create socket
-    if ((serverSocket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
-        std::wcout << "Failed to create Socket!" << std::endl;
-        return;
-    }
-    // Enable broadcast
-    int broadcastBind = 1;
-    if (setsockopt(serverSocket, SOL_SOCKET, SO_BROADCAST, &broadcastBind, sizeof(broadcastBind)) < 0) {
-        std::wcout << "Failed to enable broadcast!" << std::endl;
-        close(serverSocket);
-        return;
-    }
-    // Allow reuse
-    int reuse = 1;
-    if (setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0) {
-        std::wcout << "Setsockopt failed!" << std::endl;
-        close(serverSocket);
-        return;
+        this->inPort = inPort;
+        this->outPort = outPort;
+
+        if(identifier.has_value()) {
+            this->identifier = identifier.value();
+        }
     }
 
-    // clear garbage
-    memset(&broadcast, 0, sizeof(broadcast));
-    // prepare socket
-    broadcast.sin_family = AF_INET;
-    broadcast.sin_port = htons(port);
+    void ServerDiscovery::discoveryCycle() {
+        std::thread receiveDiscoveredCycleThread([this]() {
+            receiveDiscoveredCycle();
+        });
+    
+        int serverSocket;
+        struct sockaddr_in broadcast{}, receiverAddress{};
+        const int port = this->inPort;
 
-    if (inet_pton(AF_INET, broadcastIP.c_str(), &broadcast.sin_addr) <= 0) {
-        std::wcout << "Invalid broadcast IP" << std::endl;
-        close(serverSocket);
-        return;
-    }
+        // Create socket
+        if ((serverSocket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
+            logger->log(tablog::ERROR, "Failed to create Socket!");
+            return;
+        }
+        // Enable broadcast
+        int broadcastBind = 1;
+        if (setsockopt(serverSocket, SOL_SOCKET, SO_BROADCAST, &broadcastBind, sizeof(broadcastBind)) < 0) {
+            logger->log(tablog::ERROR, "Failed to enable broadcast!");
+            close(serverSocket);
+            return;
+        }
+        // Allow reuse
+        int reuse = 1;
+        if (setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0) {
+            logger->log(tablog::ERROR, "Setsockopt failed!");
+            close(serverSocket);
+            return;
+        }
+
+        // clear garbage
+        memset(&broadcast, 0, sizeof(broadcast));
+        // prepare socket
+        broadcast.sin_family = AF_INET;
+        broadcast.sin_port = htons(port);
 
-    while (true) {
-        if (sendMessageTo(serverSocket, broadcast, containerIP.c_str()) != 0) {
-            std::wcout << "Broadcast failed!" << std::endl;
+        if (inet_pton(AF_INET, broadcastIP.c_str(), &broadcast.sin_addr) <= 0) {
+            logger->log(tablog::ERROR, "Invalid broadcast IP");
+            close(serverSocket);
             return;
         }
-        usleep(100000);
-    }
 
-    receiveDiscoveredCycleThread.join();
-}
+        while (true) {
+            std::string message = this->identifier + containerIP;
+            if (sendMessageTo(serverSocket, broadcast, message.c_str()) != 0) {
+                logger->log(tablog::ERROR, "Broadcast failed!");
+                return;
+            }
+            usleep(100000);
+        }
 
-void ServerDiscovery::receiveDiscoveredCycle() {
-    int udpSocket;
-    const int port = this->outPort; 
-    
-    udpSocket = socket(AF_INET, SOCK_DGRAM, 0);
-    if (udpSocket < 0) {
-        std::wcout << "Create socket failed!" << std::endl;
-        return;
+        receiveDiscoveredCycleThread.join();
     }
 
-    int broadcast = 1;
-    setsockopt(udpSocket, SOL_SOCKET, SO_BROADCAST, &broadcast, sizeof(broadcast));
+    void ServerDiscovery::receiveDiscoveredCycle() {
+        int udpSocket;
+        const int port = this->outPort; 
+    
+        udpSocket = socket(AF_INET, SOCK_DGRAM, 0);
+        if (udpSocket < 0) {
+            logger->log(tablog::ERROR, "Create socket failed!");
+            return;
+        }
+
+        int broadcast = 1;
+        setsockopt(udpSocket, SOL_SOCKET, SO_BROADCAST, &broadcast, sizeof(broadcast));
 
-    sockaddr_in nodeAddress{};
-    nodeAddress.sin_family = AF_INET;
-    nodeAddress.sin_addr.s_addr = inet_addr(this->containerIP.c_str());
-    nodeAddress.sin_port = htons(port);
+        sockaddr_in nodeAddress{};
+        nodeAddress.sin_family = AF_INET;
+        nodeAddress.sin_addr.s_addr = inet_addr(this->containerIP.c_str());
+        nodeAddress.sin_port = htons(port);
 
-    if (bind(udpSocket, (struct sockaddr*)&nodeAddress, sizeof(nodeAddress)) < 0) {
-        std::wcout << "UDP Socket bind failed!" << std::endl;
-        return;
-    }
+        if (bind(udpSocket, (struct sockaddr*)&nodeAddress, sizeof(nodeAddress)) < 0) {
+            logger->log(tablog::ERROR, "UDP Socket bind failed!");
+            return;
+        }
 
-    while (true) {
-        std::string newAddress = receiveMessage(udpSocket);
-        if(std::find(discoveredAddresses.begin(), discoveredAddresses.end(), newAddress) == discoveredAddresses.end()) {
-            discoveredAddresses.push_back(newAddress);
+        while (true) {
+            std::string receivedMessage = receiveMessage(udpSocket);
+            if (hasSameIdentifier(receivedMessage)) {
+                std::string newAddress = stripIdentifier(receivedMessage);
+                if(std::find(discoveredAddresses.begin(), discoveredAddresses.end(), newAddress) == discoveredAddresses.end()) {
+                    discoveredAddresses.push_back(newAddress);
+                }
+            }
         }
     }
-
 }
diff --git a/test/client/CMakeLists.txt b/test/client/CMakeLists.txt
index 4e8109c..fd2c258 100644
--- a/test/client/CMakeLists.txt
+++ b/test/client/CMakeLists.txt
@@ -9,5 +9,6 @@ file(GLOB_RECURSE SOURCES "./*.cpp" "./*.h")
 add_executable(tud-client ${SOURCES})
 
 target_link_libraries(tud-client PRIVATE tud)
+target_link_libraries(tud-client PRIVATE tablog)
 
 install(TARGETS tud-client DESTINATION bin)
diff --git a/test/client/main.cpp b/test/client/main.cpp
index f41f984..e3c842a 100644
--- a/test/client/main.cpp
+++ b/test/client/main.cpp
@@ -1,5 +1,8 @@
 #include "client_discovery.h"
 
+#include <tablog_registry.h>
+#include <tablog.h>
+
 #include <iostream>
 #include <string>
 #include <thread>
@@ -7,23 +10,30 @@
 #include <vector>
 #include <algorithm>
 
+using namespace tud;
+
 int main() {
+    tablog::TablogRegistry* registry = &tablog::TablogRegistry::getInstance();
+    std::shared_ptr<tablog::Tablog> logger = std::make_shared<tablog::Tablog>();
+    logger->configure("TUD-client", true);
+    registry->registerLogger("TUD-client", logger);
+    
     std::string interface;
-    std::wcout << "Interface: ";
+    std::cout << "Interface: ";
     std::cin >> interface;
 
-    auto clientDiscovery = std::make_shared<ClientDiscovery>(interface, 4000, 4001);
+    auto clientDiscovery = std::make_shared<tud::ClientDiscovery>(interface, 4000, 4001, "tud");
     std::thread clientDiscoveryThread([clientDiscovery]() {
       clientDiscovery->discoveryCycle();
     });
 
-    std::wcout << "~~ Discovered Addresses ~~" << std::endl;
+    logger->log(tablog::INFO, "~~ Discovered Addresses ~~");
     std::vector<std::string> discoveredAddresses;
     while(true) {
-      std::vector<std::string> newDiscoveries = clientDiscovery->getDiscoveredAdresses();
+      std::vector<std::string> newDiscoveries = clientDiscovery->getDiscoveredAddresses();
       for (int index = 0; index < newDiscoveries.size(); index++) {
         if(std::find(discoveredAddresses.begin(), discoveredAddresses.end(), newDiscoveries[index]) == discoveredAddresses.end()) {
-          std::wcout << "--> " << newDiscoveries[index].c_str() << std::endl;
+          logger->log(tablog::INFO, "--> " + newDiscoveries[index]);
           discoveredAddresses.push_back(newDiscoveries[index]);
         }
       }
diff --git a/test/server/CMakeLists.txt b/test/server/CMakeLists.txt
index 5a3325b..fa83072 100644
--- a/test/server/CMakeLists.txt
+++ b/test/server/CMakeLists.txt
@@ -9,5 +9,6 @@ file(GLOB_RECURSE SOURCES "./*.cpp" "./*.h")
 add_executable(tud-server ${SOURCES})
 
 target_link_libraries(tud-server PRIVATE tud)
+target_link_libraries(tud-server PRIVATE tablog)
 
 install(TARGETS tud-server DESTINATION bin)
diff --git a/test/server/main.cpp b/test/server/main.cpp
index b3535e5..1c4b7c9 100644
--- a/test/server/main.cpp
+++ b/test/server/main.cpp
@@ -1,5 +1,8 @@
 #include "server_discovery.h"
 
+#include <tablog_registry.h>
+#include <tablog.h>
+
 #include <iostream>
 #include <string>
 #include <thread>
@@ -7,23 +10,30 @@
 #include <vector>
 #include <algorithm>
 
+using namespace tud;
+
 int main() {
+    tablog::TablogRegistry* registry = &tablog::TablogRegistry::getInstance();
+    std::shared_ptr<tablog::Tablog> logger = std::make_shared<tablog::Tablog>();
+    logger->configure("TUD-server", true);
+    registry->registerLogger("TUD-server", logger);
+
     std::string interface;
-    std::wcout << "Interface: ";
+    std::cout << "Interface: ";
     std::cin >> interface;
       
-    auto serverDiscovery = std::make_shared<ServerDiscovery>(interface, 4000, 4001);
+    auto serverDiscovery = std::make_shared<tud::ServerDiscovery>(interface, 4000, 4001, "tud");
     std::thread serverDiscoveryThread([serverDiscovery]() {
       serverDiscovery->discoveryCycle();
     });
 
-    std::wcout << "~~ Discovered Addresses ~~" << std::endl;
+    logger->log(tablog::INFO, "~~ Discovered Addresses ~~");
     std::vector<std::string> discoveredAddresses;
     while(true) {
-      std::vector<std::string> newDiscoveries = serverDiscovery->getDiscoveredAdresses();
+      std::vector<std::string> newDiscoveries = serverDiscovery->getDiscoveredAddresses();
       for (int index = 0; index < newDiscoveries.size(); index++) {
         if(std::find(discoveredAddresses.begin(), discoveredAddresses.end(), newDiscoveries[index]) == discoveredAddresses.end()) {
-          std::wcout << "--> " << newDiscoveries[index].c_str() << std::endl;
+          logger->log(tablog::INFO, "--> " + newDiscoveries[index]);
           discoveredAddresses.push_back(newDiscoveries[index]);
         }
       }