SocketHandler

By / 24 May 2025 / 3 minutes of reading

SocketHandler is a logging handler in the java.util.logging package that sends log messages to a remote logging server using TCP sockets.

This is useful for:

  • Distributed systems
  • Centralized logging
  • Real-time monitoring

It requires a logging server to receive and process logs (typically using SocketHandler + SocketHandlerServer or a custom SocketHandlerListener).

Commonly Used Methods

Simple Program

Logging Client: SocketLoggerClient.java

import java.io.IOException;
import java.util.logging.*;

public class SocketLoggerClient {
    public static void main(String[] args) {
        Logger logger = Logger.getLogger("network.logger");

        try {
            SocketHandler handler = new SocketHandler("localhost", 5000);
            handler.setFormatter(new SimpleFormatter());
            handler.setLevel(Level.ALL);

            logger.addHandler(handler);
            logger.setUseParentHandlers(false);
            logger.setLevel(Level.ALL);

            logger.info("This is an INFO log sent over the network.");
            logger.severe("This is a SEVERE log sent to the remote server.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Simple Logging Server: SocketLogServer.java

import java.io.*;
import java.net.*;
import java.util.logging.*;

public class SocketLogServer {
    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(5000)) {
            System.out.println("SocketLogServer is running...");

            while (true) {
                Socket client = serverSocket.accept();
                new Thread(() -> handleClient(client)).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void handleClient(Socket socket) {
        try (ObjectInputStream ois = new ObjectInputStream(socket.getInputStream())) {
            LogRecord record;
            while ((record = (LogRecord) ois.readObject()) != null) {
                System.out.println("[" + record.getLevel() + "] " + record.getMessage());
            }
        } catch (EOFException eof) {
            // Client closed
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Server displays logs received from the client:

[INFO] This is an INFO log sent over the network.
[SEVERE] This is a SEVERE log sent to the remote server.Code language: CSS (css)

Problem Statement

LotusJavaPrince and Mahesh are designing a fraud detection system for a multi-branch bank. Each branch logs activity locally, but for real-time monitoring, logs must also be sent to a central server using SocketHandler.

BranchTransactionLogger.java
import java.io.IOException;
import java.util.logging.*;

public class BranchTransactionLogger {
    public static void main(String[] args) {
        Logger logger = Logger.getLogger("com.bank.branch");

        try {
            SocketHandler socketHandler = new SocketHandler("localhost", 6000);
            socketHandler.setFormatter(new SimpleFormatter());
            socketHandler.setLevel(Level.ALL);

            logger.addHandler(socketHandler);
            logger.setUseParentHandlers(false);
            logger.setLevel(Level.ALL);

            logTransaction(logger, "LotusJavaPrince", 5000, true);
            logTransaction(logger, "Mahesh", 15000, false);
            logTransaction(logger, "UnknownUser", 99999, false);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void logTransaction(Logger logger, String user, double amount, boolean success) {
        if (success) {
            logger.info(user + " successfully transacted $" + amount);
        } else {
            logger.severe("Transaction alert: " + user + " failed or suspicious transaction: $" + amount);
        }
    }
}
Central Server: CentralLogMonitor.java
import java.io.*;
import java.net.*;
import java.util.logging.*;

public class CentralLogMonitor {
    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(6000)) {
            System.out.println("Central Fraud Monitor Running...");

            while (true) {
                Socket client = serverSocket.accept();
                new Thread(() -> listenToBranch(client)).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void listenToBranch(Socket socket) {
        try (ObjectInputStream input = new ObjectInputStream(socket.getInputStream())) {
            LogRecord record;
            while ((record = (LogRecord) input.readObject()) != null) {
                System.out.println("[FraudLog][" + record.getLevel() + "]: " + record.getMessage());
            }
        } catch (EOFException e) {
            // End of stream
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

SocketHandler is powerful for enterprise-grade logging, where remote monitoring and analysis are required.With Java’s LogRecord object, you can transmit structured logs and apply filters or alerting on the server.It’s commonly used in conjunction with custom servers or integrated into log aggregators (like Logstash or Splunk).

Related Posts

Scroll to Top