syslog.go

// Copyright 2012-2024 The NATS Authors
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//go:build !windows

package logger

import (
"fmt"
"log"
"log/syslog"
"net/url"
"os"
"strings"
)

// SysLogger provides a system logger facility
typeSysLoggerstruct {
writer*syslog.Writer
debugbool
tracebool
}

// SetSyslogName sets the name to use for the syslog.
// Currently used only on Windows.
funcSetSyslogName(namestring) {}

// GetSysLoggerTag generates the tag name for use in syslog statements. If
// the executable is linked, the name of the link will be used as the tag,
// otherwise, the name of the executable is used. "nats-server" is the default
// for the NATS server.
funcGetSysLoggerTag() string {
procName:=os.Args[0]
ifstrings.ContainsRune(procName, os.PathSeparator) {
parts:=strings.FieldsFunc(procName, func(crune) bool {
returnc==os.PathSeparator
 })
procName=parts[len(parts)-1]
 }
returnprocName
}

// NewSysLogger creates a new system logger
funcNewSysLogger(debug, tracebool) *SysLogger {
w, err:=syslog.New(syslog.LOG_DAEMON|syslog.LOG_NOTICE, GetSysLoggerTag())
iferr!=nil {
log.Fatalf("error connecting to syslog: %q", err.Error())
 }

return&SysLogger{
writer: w,
debug: debug,
trace: trace,
 }
}

// NewRemoteSysLogger creates a new remote system logger
funcNewRemoteSysLogger(fqnstring, debug, tracebool) *SysLogger {
network, addr:=getNetworkAndAddr(fqn)
w, err:=syslog.Dial(network, addr, syslog.LOG_DEBUG, GetSysLoggerTag())
iferr!=nil {
log.Fatalf("error connecting to syslog: %q", err.Error())
 }

return&SysLogger{
writer: w,
debug: debug,
trace: trace,
 }
}

funcgetNetworkAndAddr(fqnstring) (network, addrstring) {
u, err:=url.Parse(fqn)
iferr!=nil {
log.Fatal(err)
 }

network=u.Scheme
ifnetwork=="udp"||network=="tcp" {
addr=u.Host
 } elseifnetwork=="unix" {
addr=u.Path
 } else {
log.Fatalf("error invalid network type: %q", u.Scheme)
 }

return
}

// Noticef logs a notice statement
func (l*SysLogger) Noticef(formatstring, v...any) {
l.writer.Notice(fmt.Sprintf(format, v...))
}

// Warnf logs a warning statement
func (l*SysLogger) Warnf(formatstring, v...any) {
l.writer.Warning(fmt.Sprintf(format, v...))
}

// Fatalf logs a fatal error
func (l*SysLogger) Fatalf(formatstring, v...any) {
l.writer.Crit(fmt.Sprintf(format, v...))
}

// Errorf logs an error statement
func (l*SysLogger) Errorf(formatstring, v...any) {
l.writer.Err(fmt.Sprintf(format, v...))
}

// Debugf logs a debug statement
func (l*SysLogger) Debugf(formatstring, v...any) {
ifl.debug {
l.writer.Debug(fmt.Sprintf(format, v...))
 }
}

// Tracef logs a trace statement
func (l*SysLogger) Tracef(formatstring, v...any) {
ifl.trace {
l.writer.Notice(fmt.Sprintf(format, v...))
 }
}