Haribon v1.3.0

Haribon Release Notes

Version 1.3.0 — Observability and Stability Enhancements

Haribon v1.3.0 continues strengthening the reliability and observability layer of the load balancer. This release focuses on improving runtime stability, safer backend selection, and better production logging behavior while keeping the core architecture lightweight and predictable.

---

Improvements

Health-Aware Backend Selection

Backend selection now prioritizes healthy services more consistently and avoids routing to unhealthy nodes under edge conditions.

• Improved health-check evaluation logic
• Safer fallback behavior when health data is incomplete
• Prevents accidental routing to unavailable backends under load

---

Improved Round-Robin Stability

The round-robin mechanism has been refined to ensure:

• Stable ordering under concurrent requests
• Consistent backend rotation behavior
• Reduced risk of repeated backend selection under load

This improves fairness in request distribution across all healthy nodes.

---

Safer Logging Initialization

Logging system improvements:

• Automatic fallback to stdout if file logging fails
• More consistent log writer initialization
• Prevents silent logging failures during startup

---

Enhanced File Logging Safety

Log file handling is now more robust:

• Automatic directory creation for log paths
• Safer file opening with graceful fallback
• Better behavior in containerized environments (Docker/Kubernetes)

---

Improved Request Handling Stability

• Safer context handling for upstream requests
• Reduced risk of resource leaks in concurrent requests
• More predictable request cancellation behavior

---

Better Observability Readiness

Structured logs are now more consistent for ingestion pipelines:

• Fully JSON-formatted logs
• Stable schema for Loki / Promtail ingestion
• Consistent timestamp and duration reporting

---

Core Behavior (Unchanged)

• Round-robin load balancing
• Health-aware backend filtering
• YAML configuration support
• Environment variable overrides
• Lightweight Go binary design
• Reverse proxy forwarding

---

Logging Format

Haribon emits structured logs in this format:

{
  "time": "2026-05-04T01:31:55.3551454Z",
  "method": "GET",
  "path": "/",
  "backend": "http://localhost:4442",
  "status": 200,
  "duration_ms": 5,
  "level": "info"
}

---

Upgrade Notes

• No breaking changes
• Fully backward compatible with v1.2.x configs
• Safe to upgrade directly from v1.2.0

---

Summary

Haribon v1.3.0 improves system stability under load, strengthens observability guarantees, and makes logging and backend selection more resilient in production environments without introducing breaking changes.

Haribon v1.2.0

Haribon Release Notes

Version 1.2.0 — Health Checks and Safe Reverse Proxy Improvements

Haribon v1.2.0 introduces a major stability upgrade with active health checking, safer reverse proxy behavior, and improved request handling reliability while maintaining the lightweight round-robin architecture.

---

Improvements

Active Backend Health Checks

Haribon now continuously monitors backend availability using periodic HTTP health checks.

• Backends are marked healthy only if they respond with status codes 200–399
• Unreachable or failing backends are automatically excluded from routing

This improves uptime and prevents routing traffic to broken services.

Smart Load Balancing with Health Awareness

Round-robin selection now considers backend health status.

Only healthy backends are selected for request routing, improving reliability under partial system failure.

Safer Reverse Proxy Handling

Request forwarding has been improved to reduce protocol-level issues:

• Proper context timeout handling per request
• Safe header forwarding from client to backend
• Protection against invalid request construction

Hop-by-Hop Header Protection

Response headers are now filtered to avoid unsafe forwarding:

Ignored headers include:

• Content-Length
• Transfer-Encoding
• Connection

This prevents HTTP response corruption and fixes issues like ERR_CONTENT_LENGTH_MISMATCH.

Improved Concurrency Handling

Health checks now run concurrently per backend with controlled timeout handling, improving responsiveness without blocking the main request flow.

Backend Failure Auto-Recovery

If a backend temporarily fails:

• It is automatically marked unhealthy
• It is retried during future health check cycles

This enables automatic recovery without manual intervention.

---

Core Features Retained

• Round robin load balancing
• Reverse proxy request forwarding
• YAML configuration support
• Environment variable overrides
• Lightweight Go binary
• Concurrent request handling
• Optional logging support
• Configurable request timeout

---

Summary

Haribon v1.2.0 significantly improves reliability and production readiness by introducing active health checks and safer HTTP proxy behavior, ensuring stable traffic routing even under backend failures.

Haribon v1.1.2

Haribon Release Notes

Version 1.1.2 — Logging and Runtime Polish

Haribon v1.1.2 focuses on logging reliability, cleaner runtime behavior, and deployment usability improvements while preserving the lightweight round-robin proxy architecture.

---

Improvements

Refined Environment Variable Overrides

Host and port values continue to support runtime overrides using environment variables.

HARIBON_HOST=0.0.0.0
HARIBON_PORT=8080

This keeps deployments flexible across development, containers, and production systems.

Improved Invalid Port Handling

If HARIBON_PORT contains an invalid value, Haribon logs a clear warning and continues using the configured port value.

Better Logging Output

Request logs continue to include backend target, response status, and request duration for easier operational visibility.

Example:

GET / -> http://localhost:4442 [200]
duration=3ms

OS-Aware Default Log Paths

When file logging is enabled without a custom path:

• Linux uses /var/log/haribon.log
• Other systems use ./haribon.log

Stable Startup Validation

Haribon exits early when no backends are configured, helping prevent invalid deployments.

---

Core Features Retained

• Round robin load balancing
• Reverse proxy request forwarding
• YAML configuration
• Lightweight Go binary
• Concurrent request handling
• Optional file logging
• Request timeout protection

---

Summary

Haribon v1.1.2 improves runtime polish, logging clarity, and deployment flexibility while maintaining the simple lightweight proxy design.

Haribon v1.1.1

Haribon Release Notes

Version 1.1.1 — Stability and Configuration Refinements

Haribon v1.1.1 focuses on reliability improvements, cleaner startup behavior, and refined runtime configuration handling while preserving the lightweight round-robin proxy architecture.

---

Improvements

Runtime Environment Overrides

Host and port values continue to support runtime overrides using environment variables.

HARIBON_HOST=0.0.0.0
HARIBON_PORT=8080

This enables easier deployment across multiple environments without modifying YAML files.

Invalid Port Warning Logs

If HARIBON_PORT contains an invalid value, Haribon now logs a warning and safely falls back to the configured port.

Improved Logging Path Handling

Default log file paths remain OS-aware:

• Linux uses /var/log/haribon.log
• Other systems use ./haribon.log

This keeps deployments simple across servers and local development machines.

Safer Startup Validation

Haribon exits early when no backends are configured, preventing invalid runtime states.

Operational Consistency

This release keeps startup behavior predictable while maintaining simple configuration flow.

---

Core Features Retained

• Round robin load balancing
• Reverse proxy request forwarding
• YAML configuration
• Lightweight Go binary
• Concurrent request handling
• Optional file logging
• Request timeout protection

---

Summary

Haribon v1.1.1 improves operational stability and configuration safety with stronger validation and clearer runtime behavior while preserving the simple lightweight proxy design.

Haribon v1.1.0

Haribon Release Notes

Version 1.1.0 — Environment Overrides and Deployment Flexibility

Haribon v1.1.0 focuses on runtime configuration flexibility, making deployments easier across containers, cloud environments, and modern infrastructure while preserving the lightweight round-robin proxy core.

---

Improvements

Environment Variable Overrides

Host and port values can now be overridden at runtime using environment variables.

HARIBON_HOST=0.0.0.0
HARIBON_PORT=8080

This allows one configuration file to be reused across multiple environments.

Better Container Support

Haribon now fits more naturally into containerized deployments such as:

• Docker
• Kubernetes
• VPS instances
• Cloud platforms
• CI/CD pipelines

Safer Runtime Port Management

Ports no longer need to be hardcoded inside YAML when dynamic environments assign ports during startup.

Invalid Port Detection

If HARIBON_PORT contains an invalid value, Haribon logs the issue and continues using the configured port value.

Cleaner Config Separation

Static YAML configuration and runtime overrides are now separated more cleanly, improving maintainability.

---

Core Features Retained

• Round robin load balancing
• Reverse proxy request forwarding
• YAML configuration
• Lightweight Go binary
• Concurrent request handling
• Optional logging support

---

Summary

Haribon v1.1.0 improves deployment portability and runtime flexibility with environment variable overrides while keeping the simple lightweight proxy architecture intact.

Haribon v1.0.1

Haribon Release Notes

Version 1.0.1 — Logging and CLI Improvements

Haribon v1.0.1 focuses on operational improvements, better usability, and filesystem-aware logging behavior while keeping the lightweight round-robin proxy core stable.

---

Improvements

Configurable File Logging

Logging can be enabled through configuration with support for custom log paths.

logging: true
log_path: "./haribon.log"

When enabled, logs are written to both stdout and a file.

Smart Default Log Paths

If no log path is configured:

• Linux uses /var/log/haribon.log
• Other systems use ./haribon.log

This improves compatibility across Linux, Windows, and local development environments.

CLI Help Enhancements

The command help output now includes available commands and clearer startup usage.

haribon start --config ./haribon-config.yml

Request Duration Logging

Each proxied request logs execution duration for easier performance visibility.

Example:

GET / -> http://localhost:4442 [200]
duration=3ms

Configuration Validation

Startup now exits early when no backends are configured, reducing invalid deployments.

---

Core Features Retained

• Round robin load balancing
• Reverse proxy request forwarding
• YAML configuration
• Lightweight Go binary
• Concurrent request handling

---

Summary

Haribon v1.0.1 improves daily usability and operations with stronger logging, better CLI help, and safer startup validation while preserving the simple lightweight proxy architecture.

Argus v1.0.0

Haribon Release Notes

Version 1.0.0 — Initial Stable Release

Haribon v1.0.0 is the first stable public release of a lightweight HTTP load balancer written in Go.

This version delivers core reverse proxy and load balancing capabilities with built-in health awareness, making it suitable for local environments, labs, small services, and learning modern traffic distribution concepts.

---

Core Features

Round Robin Load Balancing

Incoming requests are distributed sequentially across available backend servers.

Request 1 -> Backend A
Request 2 -> Backend B
Request 3 -> Backend C
Request 4 -> Backend A

This improves traffic distribution and resource utilization.

Active Backend Health Checks

Haribon continuously monitors backend availability.

• Automatic health probe cycle
• Timeout-based detection
• HTTP status validation (200-399)
• Removes unhealthy nodes from rotation

If a backend fails, traffic automatically shifts to healthy nodes.

Automatic Failover

When a request to a backend fails:

• Backend is marked unhealthy
• Another healthy backend is selected automatically

This increases availability without manual intervention.

Reverse Proxy Engine

Haribon acts as an HTTP reverse proxy.

Clients connect to:

localhost:4444

Haribon forwards requests to backend servers and returns their responses transparently.

Safe HTTP Header Handling

To improve compatibility with browsers and clients, Haribon filters problematic hop-by-hop headers:

• Content-Length
• Transfer-Encoding
• Connection

This prevents:

• Broken responses
• Browser rendering errors
• ERR_CONTENT_LENGTH_MISMATCH

Client Header Forwarding

Haribon forwards request headers such as:

• Authorization
• Cookie
• Accept
• User-Agent

This enables proxying of authenticated APIs and modern web applications.

YAML Configuration

Simple configuration using YAML.

host: "0.0.0.0"
port: 4444

backends:
  - url: "http://localhost:4441"
  - url: "http://localhost:4442"
  - url: "http://localhost:4443"

Environment Variable Overrides

Supports runtime overrides:

HARIBON_HOST
HARIBON_PORT

Useful for Docker and container deployments.

Request Logging

Each request includes:

• Method
• Path
• Backend selected
• Status code
• Duration

Example:

GET /api -> http://localhost:4442 [200] (3ms)

---

Architecture

Haribon v1.0.0 is a:

Layer 7 HTTP Load Balancer / Reverse Proxy

Supports:

• HTTP request forwarding
• Round robin scheduling
• Health-aware routing
• Basic failover

---

Usage

haribon start --config haribon-config.yml

---

Best Use Cases

Ideal for:

• Local development environments
• Homelab services
• API testing
• Multi-instance apps
• Learning load balancer internals
• Lightweight internal tools

---

Known Limitations

Not included in v1.0.0:

• HTTPS / TLS termination
• Sticky sessions
• Weighted balancing
• Prometheus metrics
• Admin dashboard
• Graceful shutdown
• Retry backoff
• WebSocket optimizations
• Path-based routing

---

Summary

Haribon v1.0.0 delivers a fast, lightweight, understandable load balancer with real production concepts:

• Reverse proxying
• Round robin routing
• Health checks
• Failover
• Logging
• Configurable deployment