mirrors/Xray-core
1
0
Fork 0
mirror of https://github.com/XTLS/Xray-core.git synced 2025-04-30 09:18:34 +00:00
Code Issues Projects Releases Packages Wiki Activity

Refactor log (#3446)

Browse source 
* Refactor log

* Add new log methods

* Fix logger test

* Change all logging code

* Clean up pathObj

* Rebase to latest main

* Remove invoking method name after the dot
This commit is contained in:
yuhan6665 2024-06-29 14:32:57 -04:00 • committed by GitHub
parent 8320732743
commit 079d0bd8a9
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
291 changed files with 1837 additions and 2368 deletions
Download patch file Download diff file Expand all files Collapse all files

29
proxy/http/client.go
View file

@ -14,6 +14,7 @@ import (
"github.com/xtls/xray-core/common"
"github.com/xtls/xray-core/common/buf"
"github.com/xtls/xray-core/common/bytespool"
"github.com/xtls/xray-core/common/errors"
"github.com/xtls/xray-core/common/net"
"github.com/xtls/xray-core/common/protocol"
"github.com/xtls/xray-core/common/retry"
@ -51,12 +52,12 @@ func NewClient(ctx context.Context, config *ClientConfig) (*Client, error) {
for _, rec := range config.Server {
s, err := protocol.NewServerSpecFromPB(rec)
if err != nil {
return nil, newError("failed to get server spec").Base(err)
return nil, errors.New("failed to get server spec").Base(err)
}
serverList.AddServer(s)
}
if serverList.Size() == 0 {
return nil, newError("0 target server")
return nil, errors.New("0 target server")
}
v := core.MustFromContext(ctx)
@ -70,9 +71,9 @@ func NewClient(ctx context.Context, config *ClientConfig) (*Client, error) {
// Process implements proxy.Outbound.Process. We first create a socket tunnel via HTTP CONNECT method, then redirect all inbound traffic to that tunnel.
func (c *Client) Process(ctx context.Context, link *transport.Link, dialer internet.Dialer) error {
outbounds := session.OutboundsFromContext(ctx)
ob := outbounds[len(outbounds) - 1]
ob := outbounds[len(outbounds)-1]
if !ob.Target.IsValid() {
return newError("target not specified.")
return errors.New("target not specified.")
}
ob.Name = "http"
ob.CanSpliceCopy = 2
@ -80,7 +81,7 @@ func (c *Client) Process(ctx context.Context, link *transport.Link, dialer inter
targetAddr := target.NetAddr()
if target.Network == net.Network_UDP {
return newError("UDP is not supported by HTTP outbound")
return errors.New("UDP is not supported by HTTP outbound")
}
var user *protocol.MemoryUser
@ -97,7 +98,7 @@ func (c *Client) Process(ctx context.Context, link *transport.Link, dialer inter
header, err := fillRequestHeader(ctx, c.header)
if err != nil {
return newError("failed to fill out header").Base(err)
return errors.New("failed to fill out header").Base(err)
}
if err := retry.ExponentialBackoff(5, 100).On(func() error {
@ -117,12 +118,12 @@ func (c *Client) Process(ctx context.Context, link *transport.Link, dialer inter
}
return err
}); err != nil {
return newError("failed to find an available destination").Base(err)
return errors.New("failed to find an available destination").Base(err)
}
defer func() {
if err := conn.Close(); err != nil {
newError("failed to closed connection").Base(err).WriteToLog(session.ExportIDToError(ctx))
errors.LogInfoInner(ctx, err, "failed to closed connection")
}
}()
@ -160,7 +161,7 @@ func (c *Client) Process(ctx context.Context, link *transport.Link, dialer inter
responseDonePost := task.OnSuccess(responseFunc, task.Close(link.Writer))
if err := task.Run(ctx, requestFunc, responseDonePost); err != nil {
return newError("connection ends").Base(err)
return errors.New("connection ends").Base(err)
}
return nil
@ -174,10 +175,10 @@ func fillRequestHeader(ctx context.Context, header []*Header) ([]*Header, error)
inbound := session.InboundFromContext(ctx)
outbounds := session.OutboundsFromContext(ctx)
ob := outbounds[len(outbounds) - 1]
ob := outbounds[len(outbounds)-1]
if inbound == nil || ob == nil {
return nil, newError("missing inbound or outbound metadata from context")
return nil, errors.New("missing inbound or outbound metadata from context")
}
data := struct {
@ -242,7 +243,7 @@ func setUpHTTPTunnel(ctx context.Context, dest net.Destination, target string, u
if resp.StatusCode != http.StatusOK {
rawConn.Close()
return nil, newError("Proxy responded with non 200 code: " + resp.Status)
return nil, errors.New("Proxy responded with non 200 code: " + resp.Status)
}
return rawConn, nil
}
@ -274,7 +275,7 @@ func setUpHTTPTunnel(ctx context.Context, dest net.Destination, target string, u
if resp.StatusCode != http.StatusOK {
rawConn.Close()
return nil, newError("Proxy responded with non 200 code: " + resp.Status)
return nil, errors.New("Proxy responded with non 200 code: " + resp.Status)
}
return newHTTP2Conn(rawConn, pw, resp.Body), nil
}
@ -344,7 +345,7 @@ func setUpHTTPTunnel(ctx context.Context, dest net.Destination, target string, u
return proxyConn, err
default:
return nil, newError("negotiated unsupported application layer protocol: " + nextProto)
return nil, errors.New("negotiated unsupported application layer protocol: " + nextProto)
}
}

9
proxy/http/errors.generated.go
View file

@ -1,9 +0,0 @@
package http
import "github.com/xtls/xray-core/common/errors"
type errPathObjHolder struct{}
func newError(values ...interface{}) *errors.Error {
return errors.New(values...).WithPathObj(errPathObjHolder{})
}

24
proxy/http/server.go
View file

@ -94,12 +94,12 @@ func (s *Server) Process(ctx context.Context, network net.Network, conn stat.Con
Start:
if err := conn.SetReadDeadline(time.Now().Add(s.policy().Timeouts.Handshake)); err != nil {
newError("failed to set read deadline").Base(err).WriteToLog(session.ExportIDToError(ctx))
errors.LogInfoInner(ctx, err, "failed to set read deadline")
}
request, err := http.ReadRequest(reader)
if err != nil {
trace := newError("failed to read http request").Base(err)
trace := errors.New("failed to read http request").Base(err)
if errors.Cause(err) != io.EOF && !isTimeout(errors.Cause(err)) {
trace.AtWarning()
}
@ -116,9 +116,9 @@ Start:
}
}
newError("request to Method [", request.Method, "] Host [", request.Host, "] with URL [", request.URL, "]").WriteToLog(session.ExportIDToError(ctx))
errors.LogInfo(ctx, "request to Method [", request.Method, "] Host [", request.Host, "] with URL [", request.URL, "]")
if err := conn.SetReadDeadline(time.Time{}); err != nil {
newError("failed to clear read deadline").Base(err).WriteToLog(session.ExportIDToError(ctx))
errors.LogDebugInner(ctx, err, "failed to clear read deadline")
}
defaultPort := net.Port(80)
@ -131,7 +131,7 @@ Start:
}
dest, err := http_proto.ParseHost(host, defaultPort)
if err != nil {
return newError("malformed proxy host: ", host).AtWarning().Base(err)
return errors.New("malformed proxy host: ", host).AtWarning().Base(err)
}
ctx = log.ContextWithAccessMessage(ctx, &log.AccessMessage{
From: conn.RemoteAddr(),
@ -160,7 +160,7 @@ Start:
func (s *Server) handleConnect(ctx context.Context, _ *http.Request, reader *bufio.Reader, conn stat.Connection, dest net.Destination, dispatcher routing.Dispatcher, inbound *session.Inbound) error {
_, err := conn.Write([]byte("HTTP/1.1 200 Connection established\r\n\r\n"))
if err != nil {
return newError("failed to write back OK response").Base(err)
return errors.New("failed to write back OK response").Base(err)
}
plcy := s.policy()
@ -209,13 +209,13 @@ func (s *Server) handleConnect(ctx context.Context, _ *http.Request, reader *buf
if err := task.Run(ctx, closeWriter, responseDone); err != nil {
common.Interrupt(link.Reader)
common.Interrupt(link.Writer)
return newError("connection ends").Base(err)
return errors.New("connection ends").Base(err)
}
return nil
}
var errWaitAnother = newError("keep alive")
var errWaitAnother = errors.New("keep alive")
func (s *Server) handlePlainHTTP(ctx context.Context, request *http.Request, writer io.Writer, dest net.Destination, dispatcher routing.Dispatcher) error {
if !s.config.AllowTransparent && request.URL.Host == "" {
@ -274,7 +274,7 @@ func (s *Server) handlePlainHTTP(ctx context.Context, request *http.Request, wri
requestWriter := buf.NewBufferedWriter(link.Writer)
common.Must(requestWriter.SetBuffered(false))
if err := request.Write(requestWriter); err != nil {
return newError("failed to write whole request").Base(err).AtWarning()
return errors.New("failed to write whole request").Base(err).AtWarning()
}
return nil
}
@ -295,7 +295,7 @@ func (s *Server) handlePlainHTTP(ctx context.Context, request *http.Request, wri
}
defer response.Body.Close()
} else {
newError("failed to read response from ", request.Host).Base(err).AtWarning().WriteToLog(session.ExportIDToError(ctx))
errors.LogWarningInner(ctx, err, "failed to read response from ", request.Host)
response = &http.Response{
Status: "Service Unavailable",
StatusCode: 503,
@ -311,7 +311,7 @@ func (s *Server) handlePlainHTTP(ctx context.Context, request *http.Request, wri
response.Header.Set("Proxy-Connection", "close")
}
if err := response.Write(writer); err != nil {
return newError("failed to write response").Base(err).AtWarning()
return errors.New("failed to write response").Base(err).AtWarning()
}
return nil
}
@ -319,7 +319,7 @@ func (s *Server) handlePlainHTTP(ctx context.Context, request *http.Request, wri
if err := task.Run(ctx, requestDone, responseDone); err != nil {
common.Interrupt(link.Reader)
common.Interrupt(link.Writer)
return newError("connection ends").Base(err)
return errors.New("connection ends").Base(err)
}
return result