diff --git a/helmetcli.cpp b/helmetcli.cpp
index ded3d82..f086589 100644
--- a/helmetcli.cpp
+++ b/helmetcli.cpp
@@ -10,12 +10,12 @@ int main(int argc, char** argv) {
         UxClient client;
         auto connectRes = client.Connect("127.0.0.1", 1025);
         if (!connectRes) {
-                uxlogger.Log(connectRes.error());
+                uxlogger.Error(connectRes.error());
                 return 1;
         }
         auto runRes = client.Run();
         if (!runRes) {
-                uxlogger.Log(runRes.error());
+                uxlogger.Error(runRes.error());
                 return 1;
         }
 
diff --git a/helmetsrv.cpp b/helmetsrv.cpp
index 58bf211..2507c37 100644
--- a/helmetsrv.cpp
+++ b/helmetsrv.cpp
@@ -38,7 +38,7 @@ std::expected<void, std::string> Run() {
 int main(int argc, char** argv) {
         auto runRes = Run();
         if (!runRes) {
-                uxlogger.Log(runRes.error());
+                uxlogger.Error(runRes.error());
                 return 1;
         }
         return 0;
diff --git a/sockhand.cpp b/sockhand.cpp
index 8c14755..1315d91 100644
--- a/sockhand.cpp
+++ b/sockhand.cpp
@@ -46,19 +46,19 @@ void SocketHandler::Handle(int newsock, std::string laddr, std::string raddr, st
         std::thread recvThr(&SocketHandler::RecvMessages, this);
         recvThr.detach();
         {
-                uxlogger.Log(std::format("Send debug empty message"));
+                uxlogger.Debug(std::format("Send debug empty message"));
                 MessageHeader header(0);
                 auto rawHeader = header.Encode();
                 int wsize;
                 if ((wsize = write(sock, rawHeader.data(), rawHeader.size())) < 0) {
                         int errnoCopy = errno;
                         std::string error = std::strerror(errnoCopy);
-                        uxlogger.Log(std::format("Write message error: {}", error));
+                        uxlogger.Error(std::format("Write message error: {}", error));
                         return;
                 }
         }
         {
-                uxlogger.Log(std::format("Send address message"));
+                uxlogger.Debug(std::format("Send address message"));
                 uxcontrol::AddressMessage addrMsg;
                 auto meta = addrMsg.mutable_meta();
                 meta->set_kind(tunAddressMsg);
@@ -77,7 +77,7 @@ void SocketHandler::Handle(int newsock, std::string laddr, std::string raddr, st
                 if ((wsize = write(sock, rawPacket.data(), rawPacket.size())) < 0) {
                         int errnoCopy = errno;
                         std::string error = std::strerror(errnoCopy);
-                        uxlogger.Log(std::format("Write message error: {}", error));
+                        uxlogger.Error(std::format("Write message error: {}", error));
                         return;
                 }
         }
@@ -96,7 +96,7 @@ void SocketHandler::Handle(int newsock, std::string laddr, std::string raddr, st
                 auto network = networkRes.value();
                 auto prefix = prefixRes.value();
 
-                uxlogger.Log(std::format("Send route message for {}/{}", network, prefix));
+                uxlogger.Info(std::format("Send route message for {}/{}", network, prefix));
                 uxcontrol::RouteMessage routeMsg;
                 auto meta = routeMsg.mutable_meta();
                 meta->set_kind(localRouteMsg);
@@ -115,7 +115,7 @@ void SocketHandler::Handle(int newsock, std::string laddr, std::string raddr, st
                 if ((wsize = write(sock, rawPacket.data(), rawPacket.size())) < 0) {
                         int errnoCopy = errno;
                         std::string error = std::strerror(errnoCopy);
-                        uxlogger.Log(std::format("Write message error: {}", error));
+                        uxlogger.Error(std::format("Write message error: {}", error));
                         return;
                 }
 
@@ -124,7 +124,7 @@ void SocketHandler::Handle(int newsock, std::string laddr, std::string raddr, st
         sendThr.detach();
 
         done.acquire();
-        uxlogger.Log("Handler done");
+        uxlogger.Debug("Handler done");
 }
 
 void SocketHandler::SendMessages(void) {
@@ -163,7 +163,7 @@ void SocketHandler::SendMessages(void) {
 
         }
         done.release();
-        uxlogger.Log("Send messages done");
+        uxlogger.Info("Send messages done");
 }
 
 void SocketHandler::RecvMessages(void) {
@@ -173,17 +173,17 @@ void SocketHandler::RecvMessages(void) {
                 if ((rsize = recv(sock, rawHeader.data(), rawHeader.size(), MSG_WAITALL)) < 0) {
                         int errnoCopy = errno;
                         std::string error = std::strerror(errnoCopy);
-                        uxlogger.Log(std::format("Read header error: {}", error));
+                        uxlogger.Error(std::format("Read header error: {}", error));
                         break;
                 }
                 if (rsize < msgHeaderSize) {
-                        uxlogger.Log(std::format("Read only {} from {} header bytes", rsize, msgHeaderSize));
+                        uxlogger.Error(std::format("Read only {} from {} header bytes", rsize, msgHeaderSize));
                         break;
                 }
                 MessageHeader header;
                 auto decodeRes = header.Decode(rawHeader);
                 if (!decodeRes) {
-                        uxlogger.Log(std::format("Decode header error: {}", decodeRes.error()));
+                        uxlogger.Error(std::format("Decode header error: {}", decodeRes.error()));
                         break;
                 }
                 auto pSize = header.PayloadSize();
@@ -194,7 +194,7 @@ void SocketHandler::RecvMessages(void) {
                 if ((rsize = recv(sock, rawMessage.data(), rawMessage.size(), MSG_WAITALL)) < 0) {
                         int errnoCopy = errno;
                         std::string error = std::strerror(errnoCopy);
-                        uxlogger.Log(std::format("Read message error: {}", error));
+                        uxlogger.Error(std::format("Read message error: {}", error));
                         break;
                 }
                 uxcontrol::SimpleMessage simpleMsg;
@@ -218,5 +218,5 @@ void SocketHandler::RecvMessages(void) {
                 }
         }
         done.release();
-        uxlogger.Log("Recv messages done");
+        uxlogger.Info("Recv messages done");
 }
diff --git a/uxclient.cpp b/uxclient.cpp
index 8410604..0c8102d 100644
--- a/uxclient.cpp
+++ b/uxclient.cpp
@@ -87,22 +87,21 @@ void UxClient::RecvMessages(void) {
                 std::string rawHeader(msgHeaderSize, 0);
                 if ((rsize = recv(sock, rawHeader.data(), rawHeader.size(), MSG_WAITALL)) < 0) {
                         int errnoCopy = errno;
-                        uxlogger.Log(std::format("Read0 header error: {}", errno));
                         std::string error = std::strerror(errnoCopy);
-                        uxlogger.Log(std::format("Read header error: {}", error));
+                        uxlogger.Error(std::format("Read header error: {}", error));
                         break;
                 }
                 if (rsize < msgHeaderSize) {
-                        uxlogger.Log(std::format("Read only {} from {} bytes", rsize, msgHeaderSize));
+                        uxlogger.Error(std::format("Read only {} from {} bytes", rsize, msgHeaderSize));
                         break;
                 }
                 MessageHeader header;
                 auto decodeRes = header.Decode(rawHeader);
                 if (!decodeRes) {
-                        uxlogger.Log(std::format("Decode header error: {}", decodeRes.error()));
+                        uxlogger.Error(std::format("Decode header error: {}", decodeRes.error()));
                 }
                 auto pSize = header.PayloadSize();
-                uxlogger.Log(std::format("Receive message with size {}", pSize));
+                uxlogger.Error(std::format("Receive message with size {}", pSize));
                 if (pSize == 0) {
                         continue;
                 }
@@ -111,14 +110,14 @@ void UxClient::RecvMessages(void) {
                 if ((rsize = recv(sock, rawMessage.data(), rawMessage.size(), MSG_WAITALL)) < 0) {
                         int errnoCopy = errno;
                         std::string error = std::strerror(errnoCopy);
-                        uxlogger.Log(std::format("Read message error: {}", error));
+                        uxlogger.Error(std::format("Read message error: {}", error));
                         break;
                 }
                 uxcontrol::SimpleMessage meta;
                 meta.ParseFromString(rawMessage);
                 auto metaPart = meta.meta();
                 auto kind = metaPart.kind();
-                uxlogger.Debug(std::format("Received message kind of {}", kind));
+                uxlogger.Debug(std::format("Received message kind: {}", kind));
 
                 if (kind == tunAddressMsg) {
                         uxcontrol::AddressMessage addrMessage;
@@ -176,7 +175,8 @@ void UxClient::SendMessages(void) {
         while (true) {
                 auto readRes = interface.Read();
                 if (!readRes) {
-                        uxlogger.Log(std::format("Read packet error: {}", readRes.error()));
+                        uxlogger.Error(std::format("Read packet error: {}", readRes.error()));
+                        break;
                 }
                 auto packet = readRes.value();
 
@@ -199,10 +199,10 @@ void UxClient::SendMessages(void) {
                 if ((wsize = send(sock, rawPacket.data(), rawPacket.size(), 0)) < 0) {
                         int errnoCopy = errno;
                         std::string error = std::strerror(errnoCopy);
-                        uxlogger.Log(std::format("Write packet error: {}", error));
+                        uxlogger.Error(std::format("Write packet error: {}", error));
                         break;
                 }
-                uxlogger.Log("Send message");
+                uxlogger.Debug("Send internet message");
         }
         done.release();
         return;
@@ -247,7 +247,7 @@ std::expected<void, std::string> UxClient::Run(void) {
         recvThr.detach();
 
         done.acquire();
-        uxlogger.Log("Client done");
+        uxlogger.Info("Client done");
         return {};
 }
 
diff --git a/uxlogger.cpp b/uxlogger.cpp
index 2e1573f..e048aa8 100644
--- a/uxlogger.cpp
+++ b/uxlogger.cpp
@@ -15,21 +15,7 @@ UxLogger uxlogger;
 
 static std::mutex mtx;
 
-UxLogger::UxLogger(const std::string ilabel) {
-        label = ilabel;
-}
-
-UxLogger::UxLogger(void) {
-        label = "global";
-}
-
-void UxLogger::Log(const std::string& message) {
-        auto now = std::chrono::system_clock::now();
-        std::chrono::zoned_time localnow{std::chrono::current_zone(), now};
-        std::string timenow = std::format("{:%Y-%m-%dT%H:%M:%OS%Z}", localnow);
-        std::lock_guard<std::mutex> lock(mtx);
-        std::cout << std::format("{} {} {}\n", timenow, label, message);
-}
+UxLogger::UxLogger(void) {}
 
 void UxLogger::Debug(const std::string& message) {
         LogLevel("debug", message);
@@ -52,6 +38,6 @@ void UxLogger::LogLevel(const std::string level, const std::string& message) {
         std::chrono::zoned_time localnow{std::chrono::current_zone(), now};
         std::string timenow = std::format("{:%Y-%m-%dT%H:%M:%OS%Z}", localnow);
         std::lock_guard<std::mutex> lock(mtx);
-        std::cout << std::format("{} {} {} {}\n", timenow, level, label, message);
+        std::cout << std::format("{} [{}] {}\n", timenow, level, message);
 }
 
diff --git a/uxlogger.hpp b/uxlogger.hpp
index b6cf059..6b4af9a 100644
--- a/uxlogger.hpp
+++ b/uxlogger.hpp
@@ -13,9 +13,7 @@ private:
         std::string label;
         void LogLevel(const std::string level, const std::string& message);
 public:
-        UxLogger(std::string ilabel);
         UxLogger();
-        void Log(const std::string& message);
         void Debug(const std::string& message);
         void Info(const std::string& message);
         void Warning(const std::string& message);