Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 README.md # Example Demonstrates how the Go standard library `httptrace` can be used with the SDK to collect HTTP request tracing timing using the SDK's API operation methods like SNS's `PublishWithContext`. The `trace.go` file demonstrates how the `httptrace` package's `ClientTrace` can be created to gather timing information from HTTP requests made. The `config.go` file provides additional configuration settings to control how the HTTP client and its transport is configured. Such as, timeouts, and keepalive. ## Usage Run the example providing your SNS topic's ARN as the `-topic` parameter. This example assumes that the region is provided via the environment variable and the AWS shared credentials file (~/.aws/credentials)'s `default` provide provides credentials. ```sh AWS_REGION=us-west-2 go run -tags example . -topic arn:aws:sns:us-west-2:0123456789:mytopicname ``` Once the example starts you'll be prompted with a `Message:` statement. Input the message that you'd like to send to the topic on a single line and hit `enter` to send it. ``` Message: My Really cool Message ``` The example will output the http trace timing information for how long the request took. ``` 2020/07/21 15:39:07 Latency: 278.508656ms, Validate: 19.515µs, Build: 190.755µs, Attempts: 1, Attempt: 0, Latency: 278.240054ms, Sign: 453.163µs, Send: 277.580235ms, Unmarshal: 202.311µs, WillRetry: false, HTTP: Latency: 277.580856ms, ConnReused: false, GetConn: 225.662398ms, WriteRequest: 325.956µs, WaitResponseFirstByte: 277.509316ms, ReadResponseHeader: 71.234µs, Conn: DNS: 20.385136ms, Connect: 14.947772ms, TLS: 189.910822ms, Message: second 2020/07/21 15:39:09 Latency: 101.936094ms, Validate: 2.644µs, Build: 67.157µs, Attempts: 1, Attempt: 0, Latency: 101.836442ms, Sign: 122.098µs, Send: 101.517516ms, Unmarshal: 191.31µs, WillRetry: false, HTTP: Latency: 101.518147ms, ConnReused: true, GetConn: 38.265µs, WriteRequest: 178.058µs, WaitResponseFirstByte: 101.457147ms, ReadResponseHeader: 60.526µs, Message: third 2020/07/21 15:39:10 Latency: 32.373919ms, Validate: 2.998µs, Build: 39.136µs, Attempts: 1, Attempt: 0, Latency: 32.295677ms, Sign: 104.978µs, Send: 32.040306ms, Unmarshal: 146.096µs, WillRetry: false, HTTP: Latency: 32.04078ms, ConnReused: true, GetConn: 33.36µs, WriteRequest: 166.508µs, WaitResponseFirstByte: 31.980933ms, ReadResponseHeader: 59.235µs, Message: fourth 2020/07/21 15:39:13 Latency: 33.353819ms, Validate: 2.002µs, Build: 36.807µs, Attempts: 1, Attempt: 0, Latency: 33.29846ms, Sign: 70.238µs, Send: 33.125914ms, Unmarshal: 98.181µs, WillRetry: false, HTTP: Latency: 33.126453ms, ConnReused: true, GetConn: 47.516µs, WriteRequest: 251.875µs, WaitResponseFirstByte: 33.05992ms, ReadResponseHeader: 66.017µs, ```	2.72 KB	2025-05-25 12:27
📄 client.go package main import ( "net" "net/http" "time" ) // NewClient creates a new HTTP Client using the ClientConfig values. func NewClient(cfg ClientConfig) http.Client { tr := &http.Transport{ Proxy: http.ProxyFromEnvironment, DialContext: (&net.Dialer{ Timeout: cfg.Timeouts.Connect, KeepAlive: 30 time.Second, DualStack: true, }).DialContext, MaxIdleConns: 100, IdleConnTimeout: cfg.Timeouts.IdleConnection, DisableKeepAlives: !cfg.KeepAlive, TLSHandshakeTimeout: cfg.Timeouts.TLSHandshake, ExpectContinueTimeout: cfg.Timeouts.ExpectContinue, ResponseHeaderTimeout: cfg.Timeouts.ResponseHeader, } return &http.Client{ Transport: tr, } }	688 B	2025-05-25 12:27
📄 config.go package main import ( "flag" "net/http" "time" ) // ClientConfig provides the timeouts from CLI flags and default values for the // example apps's configuration. type ClientConfig struct { KeepAlive bool Timeouts Timeouts } // SetupFlags initializes the CLI flags. func (c ClientConfig) SetupFlags(prefix string, flagset flag.FlagSet) { prefix += "client." flagset.BoolVar(&c.KeepAlive, prefix+"http-keep-alive", true, "Specifies if HTTP keep alive is enabled.") c.Timeouts.SetupFlags(prefix, flagset) } // Timeouts collection of HTTP client timeout values. type Timeouts struct { IdleConnection time.Duration Connect time.Duration TLSHandshake time.Duration ExpectContinue time.Duration ResponseHeader time.Duration } // SetupFlags initializes the CLI flags. func (c Timeouts) SetupFlags(prefix string, flagset flag.FlagSet) { prefix += "timeout." flagset.DurationVar(&c.IdleConnection, prefix+"idle-conn", 90time.Second, "The `timeout` of idle connects to the remote host.") flagset.DurationVar(&c.Connect, prefix+"connect", 30time.Second, "The `timeout` connecting to the remote host.") defTR := http.DefaultTransport.(*http.Transport) flagset.DurationVar(&c.TLSHandshake, prefix+"tls", defTR.TLSHandshakeTimeout, "The `timeout` waiting for the TLS handshake to complete.") c.ExpectContinue = defTR.ExpectContinueTimeout flagset.DurationVar(&c.ResponseHeader, prefix+"response-header", defTR.ResponseHeaderTimeout, "The `timeout` waiting for the TLS handshake to complete.") }	1.5 KB	2025-05-25 12:27
📄 main.go // build example package main import ( "bufio" "context" "errors" "flag" "fmt" "log" "os" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/service/sns" ) var clientCfg ClientConfig var topicARN string func init() { clientCfg.SetupFlags("", flag.CommandLine) flag.CommandLine.StringVar(&topicARN, "topic", "", "The topic `ARN` to send messages to") } func main() { if err := flag.CommandLine.Parse(os.Args[1:]); err != nil { flag.CommandLine.PrintDefaults() exitErrorf(err, "failed to parse CLI commands") } if len(topicARN) == 0 { flag.CommandLine.PrintDefaults() exitErrorf(errors.New("topic ARN required"), "") } httpClient := NewClient(clientCfg) sess, err := session.NewSession(&aws.Config{ HTTPClient: httpClient, }) if err != nil { exitErrorf(err, "failed to load config") } // Start making the requests. svc := sns.New(sess) ctx := context.Background() fmt.Printf("Message: ") // Scan messages from the input with newline separators. scanner := bufio.NewScanner(os.Stdin) for scanner.Scan() { trace, err := publishMessage(ctx, svc, topicARN, scanner.Text()) if err != nil { fmt.Fprintf(os.Stderr, "failed to publish message, %v\n", err) } log.Println(trace) fmt.Println() fmt.Printf("Message: ") } if err := scanner.Err(); err != nil { fmt.Fprintf(os.Stderr, "failed to read input, %v", err) } } // publishMessage will send the message to the SNS topic returning an request // trace for metrics. func publishMessage(ctx context.Context, svc sns.SNS, topic, msg string) (RequestTrace, error) { trace := &RequestTrace{} _, err := svc.PublishWithContext(ctx, &sns.PublishInput{ TopicArn: &topic, Message: &msg, }, trace.TraceRequest) if err != nil { return trace, err } return trace, nil } func exitErrorf(err error, msg string, args ...interface{}) { fmt.Fprintf(os.Stderr, "FAILED: %v\n"+msg+"\n", append([]interface{}{err}, args...)...) os.Exit(1) }	1.96 KB	2025-05-25 12:27
📄 trace.go package main import ( "bytes" "context" "crypto/tls" "fmt" "io" "io/ioutil" "net/http/httptrace" "strings" "time" "github.com/aws/aws-sdk-go/aws/request" ) // RequestLatency provides latencies for the SDK API request and its attempts. type RequestLatency struct { Latency time.Duration Validate time.Duration Build time.Duration Attempts []RequestAttemptLatency } // RequestAttemptLatency provides latencies for an individual request attempt. type RequestAttemptLatency struct { Latency time.Duration Err error Sign time.Duration Send time.Duration HTTP HTTPLatency Unmarshal time.Duration UnmarshalError time.Duration WillRetry bool Retry time.Duration } // HTTPLatency provides latencies for an HTTP request. type HTTPLatency struct { Latency time.Duration ConnReused bool GetConn time.Duration DNS time.Duration Connect time.Duration TLS time.Duration WriteHeader time.Duration WriteRequest time.Duration WaitResponseFirstByte time.Duration ReadHeader time.Duration ReadBody time.Duration } // RequestTrace provides the structure to store SDK request attempt latencies. // Use TraceRequest as a API operation request option to capture trace metrics // for the individual request. type RequestTrace struct { Start, Finish time.Time ValidateStart, ValidateDone time.Time BuildStart, BuildDone time.Time ReadResponseBody bool Attempts []RequestAttemptTrace } // Latency returns the latencies of the request trace components. func (t RequestTrace) Latency() RequestLatency { var attempts []RequestAttemptLatency for _, a := range t.Attempts { attempts = append(attempts, a.Latency()) } latency := RequestLatency{ Latency: safeTimeDelta(t.Start, t.Finish), Validate: safeTimeDelta(t.ValidateStart, t.ValidateDone), Build: safeTimeDelta(t.BuildStart, t.BuildDone), Attempts: attempts, } return latency } // TraceRequest is a SDK request Option that will add request handlers to an // individual request to track request latencies per attempt. Must be used only // for a single request call per RequestTrace value. func (t RequestTrace) TraceRequest(r request.Request) { t.Start = time.Now() r.Handlers.Complete.PushBack(t.onComplete) r.Handlers.Validate.PushFront(t.onValidateStart) r.Handlers.Validate.PushBack(t.onValidateDone) r.Handlers.Build.PushFront(t.onBuildStart) r.Handlers.Build.PushBack(t.onBuildDone) var attempt RequestAttemptTrace // Signing and Start attempt r.Handlers.Sign.PushFront(func(rr request.Request) { attempt = &RequestAttemptTrace{Start: time.Now()} attempt.SignStart = attempt.Start }) r.Handlers.Sign.PushBack(func(rr request.Request) { attempt.SignDone = time.Now() }) // Ensure that the http trace added to the request always uses the original // context instead of each following attempt's context to prevent conflict // with previous http traces used. origContext := r.Context() // Send r.Handlers.Send.PushFront(func(rr request.Request) { attempt.SendStart = time.Now() attempt.HTTPTrace = NewHTTPTrace(origContext) rr.SetContext(attempt.HTTPTrace) }) r.Handlers.Send.PushBack(func(rr request.Request) { attempt.SendDone = time.Now() defer func() { attempt.HTTPTrace.Finish = time.Now() }() if rr.Error != nil { return } attempt.HTTPTrace.ReadHeaderDone = time.Now() if t.ReadResponseBody { attempt.HTTPTrace.ReadBodyStart = time.Now() var w bytes.Buffer if _, err := io.Copy(&w, rr.HTTPResponse.Body); err != nil { rr.Error = err return } rr.HTTPResponse.Body.Close() rr.HTTPResponse.Body = ioutil.NopCloser(&w) attempt.HTTPTrace.ReadBodyDone = time.Now() } }) // Unmarshal r.Handlers.Unmarshal.PushFront(func(rr request.Request) { attempt.UnmarshalStart = time.Now() }) r.Handlers.Unmarshal.PushBack(func(rr request.Request) { attempt.UnmarshalDone = time.Now() }) // Unmarshal Error r.Handlers.UnmarshalError.PushFront(func(rr request.Request) { attempt.UnmarshalErrorStart = time.Now() }) r.Handlers.UnmarshalError.PushBack(func(rr request.Request) { attempt.UnmarshalErrorDone = time.Now() }) // Retry handling and delay r.Handlers.Retry.PushFront(func(rr request.Request) { attempt.RetryStart = time.Now() attempt.Err = rr.Error }) r.Handlers.AfterRetry.PushBack(func(rr request.Request) { attempt.RetryDone = time.Now() attempt.WillRetry = rr.WillRetry() }) // Complete Attempt r.Handlers.CompleteAttempt.PushBack(func(rr request.Request) { attempt.Finish = time.Now() t.Attempts = append(t.Attempts, attempt) }) } func (t RequestTrace) String() string { var w strings.Builder l := t.Latency() writeDurField(&w, "Latency", l.Latency) writeDurField(&w, "Validate", l.Validate) writeDurField(&w, "Build", l.Build) writeField(&w, "Attempts", "%d", len(t.Attempts)) for i, a := range t.Attempts { fmt.Fprintf(&w, "\n\tAttempt: %d, %s", i, a) } return w.String() } func (t RequestTrace) onComplete(request.Request) { t.Finish = time.Now() } func (t RequestTrace) onValidateStart(request.Request) { t.ValidateStart = time.Now() } func (t RequestTrace) onValidateDone(request.Request) { t.ValidateDone = time.Now() } func (t RequestTrace) onBuildStart(request.Request) { t.BuildStart = time.Now() } func (t RequestTrace) onBuildDone(request.Request) { t.BuildDone = time.Now() } // RequestAttemptTrace provides a structure for storing trace information on // the SDK's request attempt. type RequestAttemptTrace struct { Start, Finish time.Time Err error SignStart, SignDone time.Time SendStart, SendDone time.Time HTTPTrace HTTPTrace UnmarshalStart, UnmarshalDone time.Time UnmarshalErrorStart, UnmarshalErrorDone time.Time WillRetry bool RetryStart, RetryDone time.Time } // Latency returns the latencies of the request attempt trace components. func (t RequestAttemptTrace) Latency() RequestAttemptLatency { return RequestAttemptLatency{ Latency: safeTimeDelta(t.Start, t.Finish), Err: t.Err, Sign: safeTimeDelta(t.SignStart, t.SignDone), Send: safeTimeDelta(t.SendStart, t.SendDone), HTTP: t.HTTPTrace.Latency(), Unmarshal: safeTimeDelta(t.UnmarshalStart, t.UnmarshalDone), UnmarshalError: safeTimeDelta(t.UnmarshalErrorStart, t.UnmarshalErrorDone), WillRetry: t.WillRetry, Retry: safeTimeDelta(t.RetryStart, t.RetryDone), } } func (t RequestAttemptTrace) String() string { var w strings.Builder l := t.Latency() writeDurField(&w, "Latency", l.Latency) writeDurField(&w, "Sign", l.Sign) writeDurField(&w, "Send", l.Send) writeDurField(&w, "Unmarshal", l.Unmarshal) writeDurField(&w, "UnmarshalError", l.UnmarshalError) writeField(&w, "WillRetry", "%t", l.WillRetry) writeDurField(&w, "Retry", l.Retry) fmt.Fprintf(&w, "\n\t\tHTTP: %s", t.HTTPTrace) if t.Err != nil { fmt.Fprintf(&w, "\n\t\tError: %v", t.Err) } return w.String() } // HTTPTrace provides the trace time stamps of the HTTP request's segments. type HTTPTrace struct { context.Context Start, Finish time.Time GetConnStart, GetConnDone time.Time Reused bool DNSStart, DNSDone time.Time ConnectStart, ConnectDone time.Time TLSHandshakeStart, TLSHandshakeDone time.Time WriteHeaderDone time.Time WriteRequestDone time.Time FirstResponseByte time.Time ReadHeaderStart, ReadHeaderDone time.Time ReadBodyStart, ReadBodyDone time.Time } // NewHTTPTrace returns a initialized HTTPTrace for an // httptrace.ClientTrace, based on the context passed. func NewHTTPTrace(ctx context.Context) HTTPTrace { t := &HTTPTrace{ Start: time.Now(), } trace := &httptrace.ClientTrace{ GetConn: t.getConn, GotConn: t.gotConn, PutIdleConn: t.putIdleConn, GotFirstResponseByte: t.gotFirstResponseByte, Got100Continue: t.got100Continue, DNSStart: t.dnsStart, DNSDone: t.dnsDone, ConnectStart: t.connectStart, ConnectDone: t.connectDone, TLSHandshakeStart: t.tlsHandshakeStart, TLSHandshakeDone: t.tlsHandshakeDone, WroteHeaders: t.wroteHeaders, Wait100Continue: t.wait100Continue, WroteRequest: t.wroteRequest, } t.Context = httptrace.WithClientTrace(ctx, trace) return t } // Latency returns the latencies for an HTTP request. func (t HTTPTrace) Latency() HTTPLatency { latency := HTTPLatency{ Latency: safeTimeDelta(t.Start, t.Finish), ConnReused: t.Reused, WriteHeader: safeTimeDelta(t.GetConnDone, t.WriteHeaderDone), WriteRequest: safeTimeDelta(t.GetConnDone, t.WriteRequestDone), WaitResponseFirstByte: safeTimeDelta(t.WriteRequestDone, t.FirstResponseByte), ReadHeader: safeTimeDelta(t.ReadHeaderStart, t.ReadHeaderDone), ReadBody: safeTimeDelta(t.ReadBodyStart, t.ReadBodyDone), } if !t.Reused { latency.GetConn = safeTimeDelta(t.GetConnStart, t.GetConnDone) latency.DNS = safeTimeDelta(t.DNSStart, t.DNSDone) latency.Connect = safeTimeDelta(t.ConnectStart, t.ConnectDone) latency.TLS = safeTimeDelta(t.TLSHandshakeStart, t.TLSHandshakeDone) } else { latency.GetConn = safeTimeDelta(t.Start, t.GetConnDone) } return latency } func (t HTTPTrace) String() string { var w strings.Builder l := t.Latency() writeDurField(&w, "Latency", l.Latency) writeField(&w, "ConnReused", "%t", l.ConnReused) writeDurField(&w, "GetConn", l.GetConn) writeDurField(&w, "WriteHeader", l.WriteHeader) writeDurField(&w, "WriteRequest", l.WriteRequest) writeDurField(&w, "WaitResponseFirstByte", l.WaitResponseFirstByte) writeDurField(&w, "ReadHeader", l.ReadHeader) writeDurField(&w, "ReadBody", l.ReadBody) if !t.Reused { fmt.Fprintf(&w, "\n\t\t\tConn: ") writeDurField(&w, "DNS", l.DNS) writeDurField(&w, "Connect", l.Connect) writeDurField(&w, "TLS", l.TLS) } return w.String() } func (t HTTPTrace) getConn(hostPort string) { t.GetConnStart = time.Now() } func (t HTTPTrace) gotConn(info httptrace.GotConnInfo) { t.GetConnDone = time.Now() t.Reused = info.Reused } func (t HTTPTrace) putIdleConn(err error) {} func (t HTTPTrace) gotFirstResponseByte() { t.FirstResponseByte = time.Now() t.ReadHeaderStart = t.FirstResponseByte } func (t HTTPTrace) got100Continue() {} func (t HTTPTrace) dnsStart(info httptrace.DNSStartInfo) { t.DNSStart = time.Now() } func (t HTTPTrace) dnsDone(info httptrace.DNSDoneInfo) { t.DNSDone = time.Now() } func (t HTTPTrace) connectStart(network, addr string) { t.ConnectStart = time.Now() } func (t HTTPTrace) connectDone(network, addr string, err error) { t.ConnectDone = time.Now() } func (t HTTPTrace) tlsHandshakeStart() { t.TLSHandshakeStart = time.Now() } func (t HTTPTrace) tlsHandshakeDone(state tls.ConnectionState, err error) { t.TLSHandshakeDone = time.Now() } func (t HTTPTrace) wroteHeaders() { t.WriteHeaderDone = time.Now() } func (t HTTPTrace) wait100Continue() {} func (t HTTPTrace) wroteRequest(info httptrace.WroteRequestInfo) { t.WriteRequestDone = time.Now() } func safeTimeDelta(start, end time.Time) time.Duration { if start.IsZero() \|\| end.IsZero() \|\| start.After(end) { return 0 } return end.Sub(start) } func writeField(w io.Writer, field string, format string, args ...interface{}) error { _, err := fmt.Fprintf(w, "%s: "+format+", ", append([]interface{}{field}, args...)...) return err } func writeDurField(w io.Writer, field string, dur time.Duration) error { if dur == 0 { return nil } _, err := fmt.Fprintf(w, "%s: %s, ", field, dur) return err }	11.48 KB	2025-05-25 12:27

Terminal