Log Socket v2

A real-time log viewer with WebSocket support and namespace filtering, written in Go.

What's New in v2

Breaking Changes:

• Module path changed to github.com/taigrr/log-socket/v2
• CreateClient() now accepts variadic namespaces ...string parameter
• Logger type now includes Namespace field
• New NewLogger(namespace string) constructor for namespaced loggers

New Features:

• Namespace support: Organize logs by namespace (api, database, auth, etc.)
• Namespace filtering: Subscribe to specific namespaces via WebSocket
• Frontend namespace selector: Filter logs by namespace in the web UI
• Namespace API: GET /api/namespaces to list all active namespaces

Features

• Real-time log streaming via WebSocket
• Web-based log viewer with filtering capabilities
• Namespace-based log organization
• Support for multiple log levels (TRACE, DEBUG, INFO, WARN, ERROR, PANIC, FATAL)
• Color-coded log levels for better visibility
• Auto-scrolling with toggle option
• Log download functionality
• Log clearing capability
• File source tracking for each log entry

Installation

go install github.com/taigrr/log-socket/v2@latest

Quick Start

package main

import (
	"net/http"
	logger "github.com/taigrr/log-socket/v2/log"
	"github.com/taigrr/log-socket/v2/ws"
	"github.com/taigrr/log-socket/v2/browser"
)

func main() {
	defer logger.Flush()
	
	// Set up HTTP handlers
	http.HandleFunc("/ws", ws.LogSocketHandler)
	http.HandleFunc("/api/namespaces", ws.NamespacesHandler)
	http.HandleFunc("/", browser.LogSocketViewHandler)
	
	// Use default namespace
	logger.Info("Application started")
	
	// Create namespaced loggers
	apiLogger := logger.NewLogger("api")
	dbLogger := logger.NewLogger("database")
	
	apiLogger.Info("API server ready")
	dbLogger.Debug("Database connected")
	
	logger.Fatal(http.ListenAndServe(":8080", nil))
}

Usage

Starting the Server

log-socket

By default, the server runs on 0.0.0.0:8080. Specify a different address:

log-socket -addr localhost:8080

Web Interface

Open your browser and navigate to http://localhost:8080

Namespace Filtering:

• The namespace dropdown is automatically populated from /api/namespaces
• Select one or more namespaces to filter (hold Ctrl/Cmd to multi-select)
• Default is "All Namespaces" (shows everything)
• Click "Reconnect" to apply the filter

API

Logging Interface

The package provides two ways to log:

1. Package-level functions (default namespace)

logger.Trace("trace message")
logger.Debug("debug message")
logger.Info("info message")
logger.Notice("notice message")
logger.Warn("warning message")
logger.Error("error message")
logger.Panic("panic message")  // Logs and panics
logger.Fatal("fatal message")  // Logs and exits

Each has formatted (f) and line (ln) variants:

logger.Infof("User %s logged in", username)
logger.Infoln("This adds a newline")

2. Namespaced loggers

apiLogger := logger.NewLogger("api")
apiLogger.Info("Request received")

dbLogger := logger.NewLogger("database")  
dbLogger.Warn("Slow query detected")

Creating Clients with Namespace Filters

// Listen to all namespaces
client := logger.CreateClient()

// Listen to specific namespace
client := logger.CreateClient("api")

// Listen to multiple namespaces
client := logger.CreateClient("api", "database", "auth")

WebSocket API

Log Stream Endpoint

URL: ws://localhost:8080/ws

Query Parameters:

• namespaces (optional): Comma-separated list of namespaces to filter

Examples:

ws://localhost:8080/ws                     # All namespaces
ws://localhost:8080/ws?namespaces=api      # Only "api" namespace
ws://localhost:8080/ws?namespaces=api,database  # Multiple namespaces

Message Format:

{
  "timestamp": "2024-11-10T15:42:49.777298-05:00",
  "output": "API request received",
  "file": "main.go:42",
  "level": "INFO",
  "namespace": "api"
}

Namespaces List Endpoint

URL: GET http://localhost:8080/api/namespaces

Response:

{
  "namespaces": ["default", "api", "database", "auth"]
}

Web Interface Features

• Namespace Dropdown: Dynamically populated from /api/namespaces, multi-select support
• Text Search: Filter logs by content, level, namespace, or source file
• Auto-scroll: Toggle auto-scrolling with checkbox
• Download: Save all logs as a JSON file
• Clear: Remove all logs from the viewer
• Color Coding: Different log levels are color-coded
• Reconnect: Reconnect WebSocket with new namespace filter

Migration from v1

Import Path

// v1
import "github.com/taigrr/log-socket/log"

// v2
import "github.com/taigrr/log-socket/v2/log"

CreateClient Changes

// v1
client := log.CreateClient()

// v2 - specify namespace(s) or leave empty for all
client := log.CreateClient()              // All namespaces
client := log.CreateClient("api")         // Single namespace
client := log.CreateClient("api", "db")   // Multiple namespaces

New Logger Constructor

// v2 only - create namespaced logger
apiLogger := log.NewLogger("api")
apiLogger.Info("Message in api namespace")

Dependencies

• gorilla/websocket for WebSocket support

Notes

The web interface is provided as an example implementation. Users are encouraged to customize it for their specific needs. The WebSocket endpoint (/ws) can be consumed by any WebSocket client.

License

See LICENSE file for details.