diff --git a/cmd/a_main-packr.go b/cmd/a_main-packr.go index 8435336d..2223d749 100644 --- a/cmd/a_main-packr.go +++ b/cmd/a_main-packr.go @@ -7,5 +7,5 @@ import "github.com/gobuffalo/packr" // You can use the "packr clean" command to clean up this, // and any other packr generated files. func init() { - packr.PackJSONBytes("static", "default-config.toml", "\"## ATTENTION
# it is example file only. It builtin in binary and don't read from file system.
# changes in config_default.toml have no real effect.

[General]

# Seconds for issue every certificate. Cancel issue and return error if timeout.
IssueTimeout = 300

# Path to dir, which will store state and certificates
StorageDir = "storage"

# Store .json info with certificate metadata near certificate.
StoreJSONMetadata = true

# Subdomains, auto-included within certificate of main domain name
Subdomains = ["www."]

# Directory url of acme server.
#Test server: https://acme-staging-v02.api.letsencrypt.org/directory
AcmeServer = "https://acme-v02.api.letsencrypt.org/directory"

# Include other config files
# It support glob syntax
# If it has path without template - the file must exist.
# For allow optional include file - it can contain some glob symbol
# Included configs merge with current readed state.
# example=[ "config.tom[l]" ]
IncludeConfigs = []

# For prevent infinite loop and consume all memory if cycle in includes
MaxConfigFilesRead = 10000

AllowRSACert = true
AllowECDSACert = true

[Log]
EnableLogToFile = true
EnableLogToStdErr = true

# verbose level of log, one of: debug, info, warning, error, fatal
LogLevel = "info"

# Enable self log rotating
EnableRotate = true

# Enable developer mode: more stacktraces and panic (stop program) on some internal errors.
DeveloperMode = false

# Path to log file
File = "lets-proxy.log"

# Rotate log if current file size more than X MB
RotateBySizeMB = 100

# Compress old log with gzip after rotate
CompressRotated = false

# Delete old backups after X days. 0 for disable.
MaxDays = 10

# Delete old backups if old file number more then X. 0 for disable.
MaxCount = 10

[Proxy]

# Default rule of select destination address.
# It can be: IP (with default port 80), :Port (default - same IP as receive connection), IPv4:Port or [IPv6]:Port
# Must define port force if HTTPSBackend is true
DefaultTarget = ":80"

# After KeepAliveTimeoutSeconds of inactive incoming connection will close.
KeepAliveTimeoutSeconds = 900

# Array of '-' separated pairs or IP:Port. For example:
# [
#   "1.2.3.4:443-2.2.2.2:1234",
#   "3.3.3.3:333-[::1]:94"
# "]
# Mean: connections, accepted on 1.2.3.4:443 send to server 2.2.2.2:1234
# and connections accepted on 3.3.3.3:333 send to ipv6 ::1 port 94
TargetMap = []

# Array of colon separated HeaderName:HeaderValue for add to request for backend. {{Value}} is special forms, which can
# internally parsing. Now it support only special values:
# {{CONNECTION_ID}} - Id of accepted connection, generated by lets-proxy
# {{HTTP_PROTO}} - set to http/https dependence incoming connections handled
# {{SOURCE_IP}} - Remote IP of incoming connection
# {{SOURCE_PORT}} - Remote port of incoming connection
# {{SOURCE_IP}}:{{SOURCE_PORT}} - Remote IP:Port of incoming connection.
# Now it accepted only this special values, which must be exaxlty equal to examples. All other values send as is.
# But it can change and extend in future. Doesn't use {{...}} as own values.
# Example:
# ["IP:{{SOURCE_IP}}", "Proxy:lets-proxy", "Protocol:{{HTTP_PROTO}}" ]
Headers = [ "X-Forwarded-Proto:{{HTTP_PROTO}}", "X-Forwarded-For:{{SOURCE_IP}}" ]

# Use https requests to backend instead of http
HTTPSBackend = false

# Ignore backend https certificate validations if HTTPSBackend is true
HTTPSBackendIgnoreCert = true

[CheckDomains]

# Allow domain if it resolver for one of public IPs of this server.
IPSelf = true

# How detect public ips of the server.
# it use if IPSelf is true
# auto | local | aws  | yandex
# auto - best effort for detect IP. Algoritm may change from time to time.
#        it good for default.
# bind - detect public IP binded to local interfaces
# aws - detect public IPs by query to AWS EC2 metadata
# external - detect self ip by request to external server IPSelfExternalDetector
# yandex - detect public IPs by query to Yandex cloud metadata (now alias for aws)
IPSelfDetectMethod = "auto"

# Server for use as external detector of server IP (need for detect IP behind NAT
# Server must response as plain text IP address.
# For every detect lets-proxy make two requests: by ipv4 and ipv6 networks
IPSelfExternalDetectorURL="http://ifconfig.io/ip"

# Allow domain if it resolver for one of the ips.
IPWhiteList = ""

# Regexp in golang syntax of blacklisted domain for issue certificate.
#This list overrided by whitelist.
BlackList = ""

# Regexp in golang syntax of whitelist domains for issue certificate.
#Whitelist need for allow part of domains, which excluded by blacklist.
#
WhiteList = ""

# Comma separated dns server, used for resolve ip:port address of domains while check it.
# if empty - use system dns resolver (usually include hosts file, cache, etc)
# if set - use direct dns queries for servers, without self cache.
# if set more, than one dns server - send queries in parallel to all servers.
# error results from part of servers - ignore. Need minimum one answer.
# if different dns servers return different ip addresses - all of them use for check
# Example: "8.8.8.8:53,1.1.1.1:53,77.88.8.8:53,[2a02:6b8::feed:0ff]:53,[2001:4860:4860::8888]:53"
Resolver = ""



[Listen]

# Bind addresses for TLS listeners
TLSAddresses = [":443"]

# Bind addresses without TLS secure (for HTTP reverse proxy and http-01 validation without redirect to https)
TCPAddresses = []


[Metrics]
# Enable metrics in prometheous formath by http.
Enable = false

# Bind addresses for get by https
TLSAddresses = [ "[::]:62101" ]

# Bind addresses without TLS secure (for HTTP reverse proxy and http-01 validation without redirect to https)
TCPAddresses = [ "[::]:62100" ]

# IP networks for allow to get metrics.
# Default - allow from all.
# Example:
# [ "1.2.3.4/32", "192.168.0.0/24", "::1/128" ]
AllowedNetworks = []

# Password for get metrics, add as get param ?password=...
Password        = ""

# Allow set password to empty string
AllowEmptyPassword  = false



[Profiler]
Enable = false

# IP networks for allow to use profiler.
# Default - allow from all.
# Example:
# [ "1.2.3.4/32", "192.168.0.0/24", "::1/128" ]
AllowedNetworks = []
BindAddress = "localhost:31344"
Password        = ""
AllowEmptyPassword  = false
\"") + packr.PackJSONBytes("static", "default-config.toml", "\"## ATTENTION
# it is example file only. It builtin in binary and don't read from file system.
# changes in config_default.toml have no real effect.

[General]

# Seconds for issue every certificate. Cancel issue and return error if timeout.
IssueTimeout = 300

# Path to dir, which will store state and certificates
StorageDir = "storage"

# Store .json info with certificate metadata near certificate.
StoreJSONMetadata = true

# Subdomains, auto-included within certificate of main domain name
Subdomains = ["www."]

# Directory url of acme server.
#Test server: https://acme-staging-v02.api.letsencrypt.org/directory
AcmeServer = "https://acme-v02.api.letsencrypt.org/directory"

# Include other config files
# It support glob syntax
# If it has path without template - the file must exist.
# For allow optional include file - it can contain some glob symbol
# Included configs merge with current readed state.
# example=[ "config.tom[l]" ]
IncludeConfigs = []

# For prevent infinite loop and consume all memory if cycle in includes
MaxConfigFilesRead = 10000

AllowRSACert = true
AllowECDSACert = true

[Log]
EnableLogToFile = true
EnableLogToStdErr = true

# verbose level of log, one of: debug, info, warning, error, fatal
LogLevel = "info"

# Enable write info about every http request (but write info about connections if need by level)
EnableAccessLog = true

# Enable self log rotating
EnableRotate = true

# Enable developer mode: more stacktraces and panic (stop program) on some internal errors.
DeveloperMode = false

# Path to log file
File = "lets-proxy.log"

# Rotate log if current file size more than X MB
RotateBySizeMB = 100

# Compress old log with gzip after rotate
CompressRotated = false

# Delete old backups after X days. 0 for disable.
MaxDays = 10

# Delete old backups if old file number more then X. 0 for disable.
MaxCount = 10

[Proxy]

# Default rule of select destination address.
# It can be: IP (with default port 80), :Port (default - same IP as receive connection), IPv4:Port or [IPv6]:Port
# Must define port force if HTTPSBackend is true
DefaultTarget = ":80"

# After KeepAliveTimeoutSeconds of inactive incoming connection will close.
KeepAliveTimeoutSeconds = 900

# Array of '-' separated pairs or IP:Port. For example:
# [
#   "1.2.3.4:443-2.2.2.2:1234",
#   "3.3.3.3:333-[::1]:94"
# "]
# Mean: connections, accepted on 1.2.3.4:443 send to server 2.2.2.2:1234
# and connections accepted on 3.3.3.3:333 send to ipv6 ::1 port 94
TargetMap = []

# Array of colon separated HeaderName:HeaderValue for add to request for backend. {{Value}} is special forms, which can
# internally parsing. Now it support only special values:
# {{CONNECTION_ID}} - Id of accepted connection, generated by lets-proxy
# {{HTTP_PROTO}} - set to http/https dependence incoming connections handled
# {{SOURCE_IP}} - Remote IP of incoming connection
# {{SOURCE_PORT}} - Remote port of incoming connection
# {{SOURCE_IP}}:{{SOURCE_PORT}} - Remote IP:Port of incoming connection.
# Now it accepted only this special values, which must be exaxlty equal to examples. All other values send as is.
# But it can change and extend in future. Doesn't use {{...}} as own values.
# Example:
# ["IP:{{SOURCE_IP}}", "Proxy:lets-proxy", "Protocol:{{HTTP_PROTO}}" ]
Headers = [ "X-Forwarded-Proto:{{HTTP_PROTO}}", "X-Forwarded-For:{{SOURCE_IP}}" ]

# Use https requests to backend instead of http
HTTPSBackend = false

# Ignore backend https certificate validations if HTTPSBackend is true
HTTPSBackendIgnoreCert = true

[CheckDomains]

# Allow domain if it resolver for one of public IPs of this server.
IPSelf = true

# How detect public ips of the server.
# it use if IPSelf is true
# auto | local | aws  | yandex
# auto - best effort for detect IP. Algoritm may change from time to time.
#        it good for default.
# bind - detect public IP binded to local interfaces
# aws - detect public IPs by query to AWS EC2 metadata
# external - detect self ip by request to external server IPSelfExternalDetector
# yandex - detect public IPs by query to Yandex cloud metadata (now alias for aws)
IPSelfDetectMethod = "auto"

# Server for use as external detector of server IP (need for detect IP behind NAT
# Server must response as plain text IP address.
# For every detect lets-proxy make two requests: by ipv4 and ipv6 networks
IPSelfExternalDetectorURL="http://ifconfig.io/ip"

# Allow domain if it resolver for one of the ips.
IPWhiteList = ""

# Regexp in golang syntax of blacklisted domain for issue certificate.
#This list overrided by whitelist.
BlackList = ""

# Regexp in golang syntax of whitelist domains for issue certificate.
#Whitelist need for allow part of domains, which excluded by blacklist.
#
WhiteList = ""

# Comma separated dns server, used for resolve ip:port address of domains while check it.
# if empty - use system dns resolver (usually include hosts file, cache, etc)
# if set - use direct dns queries for servers, without self cache.
# if set more, than one dns server - send queries in parallel to all servers.
# error results from part of servers - ignore. Need minimum one answer.
# if different dns servers return different ip addresses - all of them use for check
# Example: "8.8.8.8:53,1.1.1.1:53,77.88.8.8:53,[2a02:6b8::feed:0ff]:53,[2001:4860:4860::8888]:53"
Resolver = ""



[Listen]

# Bind addresses for TLS listeners
TLSAddresses = [":443"]

# Bind addresses without TLS secure (for HTTP reverse proxy and http-01 validation without redirect to https)
TCPAddresses = []


[Metrics]
# Enable metrics in prometheous formath by http.
Enable = false

# Bind addresses for get by https
TLSAddresses = [ "[::]:62101" ]

# Bind addresses without TLS secure (for HTTP reverse proxy and http-01 validation without redirect to https)
TCPAddresses = [ "[::]:62100" ]

# IP networks for allow to get metrics.
# Default - allow from all.
# Example:
# [ "1.2.3.4/32", "192.168.0.0/24", "::1/128" ]
AllowedNetworks = []

# Password for get metrics, add as get param ?password=...
Password        = ""

# Allow set password to empty string
AllowEmptyPassword  = false



[Profiler]
Enable = false

# IP networks for allow to use profiler.
# Default - allow from all.
# Example:
# [ "1.2.3.4/32", "192.168.0.0/24", "::1/128" ]
AllowedNetworks = []
BindAddress = "localhost:31344"
Password        = ""
AllowEmptyPassword  = false
\"") } diff --git a/cmd/config.go b/cmd/config.go index 0bea7676..5d39e925 100644 --- a/cmd/config.go +++ b/cmd/config.go @@ -55,6 +55,7 @@ type logConfig struct { EnableLogToFile bool EnableLogToStdErr bool LogLevel string + EnableAccessLog bool EnableRotate bool DeveloperMode bool File string diff --git a/cmd/main.go b/cmd/main.go index d2fd4283..9d2f185e 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -153,6 +153,7 @@ func startProgram(config *configType) { err = tlsListener.Start(ctx, registry) log.DebugFatal(logger, err, "StartAutoRenew tls listener") + config.Proxy.EnableAccessLog = config.Log.EnableAccessLog p := proxy.NewHTTPProxy(ctx, tlsListener) p.GetContext = func(req *http.Request) (i context.Context, e error) { localAddr := req.Context().Value(http.LocalAddrContextKey).(net.Addr) diff --git a/cmd/static/default-config.toml b/cmd/static/default-config.toml index ff7fc835..10e25372 100644 --- a/cmd/static/default-config.toml +++ b/cmd/static/default-config.toml @@ -41,6 +41,9 @@ EnableLogToStdErr = true # verbose level of log, one of: debug, info, warning, error, fatal LogLevel = "info" +# Enable write info about every http request (but write info about connections if need by level) +EnableAccessLog = true + # Enable self log rotating EnableRotate = true diff --git a/internal/proxy/config.go b/internal/proxy/config.go index 6a7071fd..c76bcd21 100644 --- a/internal/proxy/config.go +++ b/internal/proxy/config.go @@ -25,6 +25,7 @@ type Config struct { KeepAliveTimeoutSeconds int HTTPSBackend bool HTTPSBackendIgnoreCert bool + EnableAccessLog bool } func (c *Config) Apply(ctx context.Context, p *HTTPProxy) error { @@ -45,7 +46,8 @@ func (c *Config) Apply(ctx context.Context, p *HTTPProxy) error { appendDirector(c.getMapDirector) appendDirector(c.getHeadersDirector) appendDirector(c.getSchemaDirector) - p.httpReverseProxy.Transport = Transport{c.HTTPSBackendIgnoreCert} + p.HTTPTransport = Transport{c.HTTPSBackendIgnoreCert} + p.EnableAccessLog = c.EnableAccessLog if resErr != nil { zc.L(ctx).Error("Can't parse proxy config", zap.Error(resErr)) diff --git a/internal/proxy/config_test.go b/internal/proxy/config_test.go index f54d089b..ec03ddba 100644 --- a/internal/proxy/config_test.go +++ b/internal/proxy/config_test.go @@ -281,12 +281,12 @@ func TestConfig_Apply(t *testing.T) { c = Config{HTTPSBackendIgnoreCert: false} p = &HTTPProxy{} _ = c.Apply(ctx, p) - transport := p.httpReverseProxy.Transport.(Transport) + transport := p.HTTPTransport.(Transport) transport.IgnoreHTTPSCertificate = false c = Config{HTTPSBackendIgnoreCert: true} p = &HTTPProxy{} _ = c.Apply(ctx, p) - transport = p.httpReverseProxy.Transport.(Transport) + transport = p.HTTPTransport.(Transport) transport.IgnoreHTTPSCertificate = true } diff --git a/internal/proxy/http-proxy.go b/internal/proxy/http-proxy.go index f55e82f0..5aacaf8a 100644 --- a/internal/proxy/http-proxy.go +++ b/internal/proxy/http-proxy.go @@ -28,6 +28,7 @@ type HTTPProxy struct { HandleHTTPValidation func(w http.ResponseWriter, r *http.Request) bool Director Director // modify requests to backend. HTTPTransport http.RoundTripper + EnableAccessLog bool logger *zap.Logger listener net.Listener @@ -61,9 +62,15 @@ func (p *HTTPProxy) Close() error { // Any public fields must not change after Start called func (p *HTTPProxy) Start() error { if p.HTTPTransport != nil { + p.logger.Info("Set transport to reverse proxy") p.httpReverseProxy.Transport = p.HTTPTransport } + if p.EnableAccessLog { + p.httpReverseProxy.Transport = NewTransportLogger(p.httpReverseProxy.Transport) + } + p.logger.Info("Access log", zap.Bool("enabled", p.EnableAccessLog)) + mux := &http.ServeMux{} mux.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) { if !p.HandleHTTPValidation(writer, request) { diff --git a/internal/proxy/transport_logger.go b/internal/proxy/transport_logger.go new file mode 100644 index 00000000..c5eaa21c --- /dev/null +++ b/internal/proxy/transport_logger.go @@ -0,0 +1,41 @@ +package proxy + +import ( + "net/http" + "time" + + "go.uber.org/zap" + + "github.com/rekby/lets-proxy2/internal/log" +) + +type TransportLogger struct { + Transport http.RoundTripper +} + +func (t TransportLogger) RoundTrip(request *http.Request) (resp *http.Response, err error) { + start := time.Now() + + defer func() { + log.InfoErrorCtx(request.Context(), err, "Request", + zap.Duration("duration_without_body", time.Since(start)), + zap.String("initiator_addr", request.RemoteAddr), + zap.String("metod", request.Method), + zap.String("host", request.Host), + zap.String("path", request.URL.Path), + zap.String("query", request.URL.RawQuery), + zap.Int("status_code", resp.StatusCode), + zap.Int64("request_content_length", request.ContentLength), + zap.Int64("resp_content_length", resp.ContentLength), + ) + }() + + return t.Transport.RoundTrip(request) +} + +func NewTransportLogger(transport http.RoundTripper) TransportLogger { + if transport == nil { + return TransportLogger{Transport: http.DefaultTransport} + } + return TransportLogger{Transport: transport} +} diff --git a/internal/proxy/transport_logger_test.go b/internal/proxy/transport_logger_test.go new file mode 100644 index 00000000..c65db40b --- /dev/null +++ b/internal/proxy/transport_logger_test.go @@ -0,0 +1,7 @@ +package proxy + +import ( + "net/http" +) + +var _ http.RoundTripper = TransportLogger{}