opensnitch/daemon/log/loggers/remote.go
Gustavo Iñiguez Goia aa37ac3e3a loggers: changed log level from Warn to Debug
When the remote logger cannot connect to the server, avoid flooding the
logs with warnings.
2025-06-05 20:47:29 +02:00

256 lines
6.1 KiB
Go

package loggers
import (
"context"
"fmt"
"log/syslog"
"net"
"os"
"strings"
"sync"
"sync/atomic"
"time"
"github.com/evilsocket/opensnitch/daemon/core"
"github.com/evilsocket/opensnitch/daemon/log"
"github.com/evilsocket/opensnitch/daemon/log/formats"
)
const (
LOGGER_REMOTE = "remote"
// restart syslog connection after these amount of errors
maxAllowedErrors = 10
)
var (
// default write / connect timeouts
writeTimeout, _ = time.ParseDuration("1s")
connTimeout, _ = time.ParseDuration("5s")
reopenInterval, _ = time.ParseDuration("5s")
)
// connection status
const (
DISCONNECTED = iota
CONNECTED
CONNECTING
)
// Remote defines a logger that writes events to a generic remote server.
// It can write to a local or a remote daemon, UDP or TCP.
// It supports writing events in RFC5424, RFC3164, CSV and JSON formats.
type Remote struct {
mu *sync.RWMutex
Writer *syslog.Writer
cfg LoggerConfig
ctx context.Context
cancel context.CancelFunc
logFormat formats.LoggerFormat
// Name of the logger
Name string
// channel used to write mesages
writerChan chan string
Tag string
// Name of the host where the daemon is running
Hostname string
// Write timeouts
Timeout time.Duration
// Connect timeout
ConnectTimeout time.Duration
status uint32
}
// NewRemote returns a new object that manipulates and prints outbound connections
// to a remote server, with the given format (RFC5424 by default)
func NewRemote(cfg LoggerConfig) (*Remote, error) {
var err error
log.Info("NewRemote logger: %v", cfg)
sys := &Remote{
mu: &sync.RWMutex{},
}
sys.Name = LOGGER_REMOTE
sys.cfg = cfg
sys.ctx, sys.cancel = context.WithCancel(context.Background())
// list of allowed formats for this logger
sys.logFormat = formats.NewRfc5424()
if cfg.Format == formats.RFC3164 {
sys.logFormat = formats.NewRfc3164()
} else if cfg.Format == formats.JSON {
sys.logFormat = formats.NewJSON()
} else if cfg.Format == formats.CSV {
sys.logFormat = formats.NewCSV()
}
sys.Tag = logTag
if cfg.Tag != "" {
sys.Tag = cfg.Tag
}
sys.Hostname, err = os.Hostname()
if err != nil {
sys.Hostname = "localhost"
}
sys.Timeout, err = time.ParseDuration(cfg.WriteTimeout)
if err != nil || cfg.WriteTimeout == "" {
sys.Timeout = writeTimeout
}
sys.ConnectTimeout, err = time.ParseDuration(cfg.ConnectTimeout)
if err != nil || cfg.ConnectTimeout == "" {
sys.ConnectTimeout = connTimeout
}
sys.writerChan = make(chan string)
if sys.cfg.Workers == 0 {
sys.cfg.Workers = 1
}
for i := 0; i < sys.cfg.Workers; i++ {
go writerWorker(i, sys, sys.writerChan, sys.ctx.Done())
}
return sys, err
}
// Open establishes a connection with a remote server.
// It'll try to reopen the connection based on the configuration provided:
// If MaxConnectAttempts is 0, indefinitely. Otherwise the amount of attempts specified.
func (s *Remote) Open() (net.Conn, bool) {
atomic.StoreUint32(&s.status, DISCONNECTED)
connRetries := uint16(0)
Reopen:
select {
case <-s.ctx.Done():
log.Info("[%s] %s worker stopped", s.Name, s.cfg.Server)
return nil, false
default:
}
log.Debug("[%s] %s trying to connect", s.Name, s.cfg.Server)
conn, err := s.Dial(s.cfg.Protocol, s.cfg.Server, s.ConnectTimeout)
if err != nil {
log.Debug("[%s] Error opening connection (%s), retrying... (%d/%d)", s.Name, s.cfg.Server, connRetries, s.cfg.MaxConnectAttempts)
connRetries++
if s.cfg.MaxConnectAttempts > 0 && connRetries > s.cfg.MaxConnectAttempts {
log.Info("[%s] %s, Max connections attempts reached, giving up", s.Name, s.cfg.Server)
return nil, false
}
// wait time before reopen attempt
time.Sleep(reopenInterval)
goto Reopen
}
connRetries = 0
atomic.StoreUint32(&s.status, CONNECTED)
log.Info("[%s] connected to %s", s.Name, s.cfg.Server)
return conn, true
}
// Dial opens a new connection with a remote server.
func (s *Remote) Dial(proto, addr string, connTimeout time.Duration) (netConn net.Conn, err error) {
atomic.StoreUint32(&s.status, DISCONNECTED)
switch proto {
case "udp", "tcp":
netConn, err = net.DialTimeout(proto, addr, connTimeout)
if err != nil {
log.Debug("remote.Dial() %s error: %s", s.cfg.Server, err)
return nil, err
}
default:
return nil, fmt.Errorf("[%s] Network protocol %s not supported (use 'tcp' or 'udp')", s.Name, proto)
}
atomic.StoreUint32(&s.status, CONNECTED)
return netConn, nil
}
// Close closes the writer object
func (s *Remote) Close() (err error) {
s.cancel()
atomic.StoreUint32(&s.status, DISCONNECTED)
return
}
func (s *Remote) isConnected() bool {
status := atomic.LoadUint32(&s.status)
return status == CONNECTED
}
// Transform transforms data for proper ingestion.
func (s *Remote) Transform(args ...interface{}) (out string) {
if s.logFormat != nil {
args = append(args, s.Hostname)
args = append(args, s.Tag)
out = s.logFormat.Transform(args...)
}
return
}
func (s *Remote) Write(msg string) {
if !s.isConnected() {
log.Trace("[%s] %s not connected", s.Name, s.cfg.Server)
return
}
s.writerChan <- msg
}
func (s *Remote) formatLine(msg string) string {
nl := ""
if !strings.HasSuffix(msg, "\n") {
nl = "\n"
}
return core.ConcatStrings(msg, nl)
}
// each worker opens a new connection with the remote server, and waits for
// incoming messages to be forwarded to the server.
func writerWorker(id int, sys *Remote, msgs <-chan string, done <-chan struct{}) {
errors := 0
Reopen:
conn, reconnected := sys.Open()
if !reconnected {
goto Exit
}
for {
select {
case <-done:
goto Exit
case msg := <-msgs:
//log.Trace("[%s] %d writing", sys.Name, id)
// define a write timeout for this operation from Now.
deadline := time.Now().Add(sys.Timeout)
conn.SetWriteDeadline(deadline)
_, err := conn.Write([]byte(msg))
if err != nil {
log.Debug("[%s] error writing via writer %d: %s", sys.Name, id, err)
errors++
if errors > maxAllowedErrors {
log.Warning("[%s] writer %d: too much errors, review the configuration and / or connectivity with the remote server", sys.Name, id)
goto Reopen
}
}
}
}
Exit:
log.Info("[%s logger] %d connection closed (errors: %d)", sys.Name, id, errors)
if conn != nil {
conn.Close()
}
sys.Close()
}