HTTP trace logging

commands.go

@@ -119,6 +119,12 @@ var COMMANDS map[string]func(string, *App) CommandFunc = map[string]func(string,
  return nil
  }
  },
+ "printTraceBuffer": func(_ string, a *App) CommandFunc {
+ return func(g *gocui.Gui, _ *gocui.View) error {
+ dumpTraceClient(g, a)
+ return nil
+ }
+ },
 }
 
 func scrollView(v *gocui.View, dy int) error {

config/config.go

@@ -62,6 +62,7 @@ var DefaultKeys = map[string]map[string]string{
  "CtrlO": "openEditor",
  "CtrlT": "toggleContextSpecificSearch",
  "CtrlX": "clearHistory",
+ "CtrlB": "printTraceBuffer",
  "Tab": "nextView",
  "CtrlJ": "nextView",
  "CtrlK": "prevView",

trace.go

@@ -0,0 +1,211 @@
+package main
+
+import (
+ "container/ring"
+ "crypto/tls"
+ "fmt"
+ "net/http/httptrace"
+ "net/textproto"
+ "strings"
+ "sync"
+ "time"
+
+ "github.com/jroimartin/gocui"
+)
+
+const (
+ ViewWidth = 80
+ ViewHeight = 25
+ BufferLength = 20
+ TimestampLayout = "15:04:05.000000"
+)
+
+type ClientTrace struct {
+ sync.Mutex
+ data *ring.Ring
+ recChannel chan string
+ writeChannel chan string
+}
+
+var (
+ clientTrace *ClientTrace
+)
+
+func NewClientTrace() *ClientTrace {
+ result := new(ClientTrace)
+ result.data = ring.New(BufferLength)
+ result.recChannel = make(chan string, 0)
+ result.writeChannel = make(chan string, 1)
+
+ go result.writer()
+ go result.receiver()
+
+ return result
+}
+
+func (c *ClientTrace) Write(format string, args ...interface{}) {
+ message := fmt.Sprintf(format, args...)
+ lineLen := ViewWidth - (len(TimestampLayout) + 3)
+ if len(message) > lineLen {
+ sb := strings.Builder{}
+ prefix := string(make([]rune, len(TimestampLayout)+3))
+
+ for i, c := range []rune(message) {
+ if i > 0 && i%lineLen == 0 && i < len(message) {
+ sb.WriteString(prefix)
+ }
+ sb.WriteRune(c)
+ }
+
+ message = sb.String()
+ }
+ message = fmt.Sprintf("[%s] %s", time.Now().Format(TimestampLayout), message)
+ c.writeChannel <- fmt.Sprintf(message)
+}
+
+func (c *ClientTrace) Dump() string {
+ c.Lock()
+ defer c.Unlock()
+
+ sb := strings.Builder{}
+ c.data.Do(func(v interface{}) {
+ if v != nil {
+ s := fmt.Sprintf("%v\n", v)
+ sb.WriteString(s)
+ }
+ })
+ return sb.String()
+}
+
+func (c *ClientTrace) receiver() {
+ for {
+ select {
+ case message, more := <-c.recChannel:
+ c.writeChannel <- message
+ if !more {
+ break
+ }
+ }
+ }
+}
+
+func (c *ClientTrace) writer() {
+ f := func(message string) {
+ c.Lock()
+ defer c.Unlock()
+ c.data.Value = message
+ c.data = c.data.Next()
+ }
+ for {
+ select {
+ case message, more := <-c.writeChannel:
+ f(message)
+ if !more {
+ break
+ }
+ }
+ }
+}
+
+func getClientTrace() *httptrace.ClientTrace {
+ if clientTrace == nil {
+ clientTrace = NewClientTrace()
+ }
+
+ return &httptrace.ClientTrace{
+ GetConn: func(hostPort string) {
+ clientTrace.Write("GetConn(%v)", hostPort)
+ },
+ GotConn: func(info httptrace.GotConnInfo) {
+ clientTrace.Write("GotConn(%v -> %v)", info.Conn.LocalAddr(), info.Conn.RemoteAddr())
+ },
+ GotFirstResponseByte: func() {
+ clientTrace.Write("GotFirstResponseByte()")
+ },
+ Got100Continue: func() {
+ clientTrace.Write("Got100Continue()")
+ },
+ Got1xxResponse: func(code int, header textproto.MIMEHeader) error {
+ clientTrace.Write("Got1xxResponse(%v, %v)", code, header)
+ return nil
+ },
+ DNSStart: func(info httptrace.DNSStartInfo) {
+ clientTrace.Write("DNSStart(%v)", info.Host)
+ },
+ DNSDone: func(info httptrace.DNSDoneInfo) {
+ if info.Err != nil {
+ clientTrace.Write("DNSDone(): ", info.Err)
+ } else {
+ clientTrace.Write("DNSDone(%v)", info.Addrs)
+ }
+ },
+ ConnectStart: func(network, addr string) {
+ clientTrace.Write("ConnectStart(%v)", addr)
+ },
+ ConnectDone: func(network, addr string, err error) {
+ if err != nil {
+ clientTrace.Write("ConnectDone(): %v", err)
+ } else {
+ clientTrace.Write("ConnectDone(%v)", addr)
+ }
+ },
+ TLSHandshakeDone: func(state tls.ConnectionState, err error) {
+ if err != nil {
+ clientTrace.Write("TLSHandshakeDone(): %v", err)
+ } else {
+ sb := strings.Builder{}
+ sb.WriteString(func(version uint16) string {
+ for k, v := range TLS_VERSIONS {
+ if v == state.Version {
+ return k
+ }
+ }
+ return "Unknown"
+ }(state.Version))
+ sb.WriteRune(' ')
+ sb.WriteString(state.ServerName)
+ sb.WriteString(" <=> ")
+ sb.WriteString(state.PeerCertificates[0].Subject.CommonName)
+ clientTrace.Write("TLSHandshakeDone(%v)", sb.String())
+ }
+ },
+ WroteHeaderField: func(key string, value []string) {
+ clientTrace.Write("WroteHeaderField(%v, %v)", key, value)
+ },
+ Wait100Continue: func() {
+ clientTrace.Write("Wait100Continue()")
+ },
+ WroteRequest: func(info httptrace.WroteRequestInfo) {
+ if info.Err != nil {
+ clientTrace.Write("WroteRequest(): %v", info)
+ } else {
+ clientTrace.Write("WroteRequest()")
+ }
+ },
+ }
+}
+
+func dumpTraceClient(g *gocui.Gui, a *App) {
+ if a.currentPopup == TRACE_VIEW {
+ a.closePopup(g, TRACE_VIEW)
+ return
+ }
+ trace, err := a.CreatePopupView(TRACE_VIEW, ViewWidth, ViewHeight, g)
+ if err != nil {
+ return
+ }
+ trace.Title = VIEW_TITLES[TRACE_VIEW]
+ trace.Highlight = false
+ trace.Wrap = true
+ if clientTrace != nil {
+ go func() {
+ for a.currentPopup == TRACE_VIEW {
+ trace.Clear()
+ _, err = fmt.Fprintf(trace, clientTrace.Dump())
+ time.Sleep(100 * time.Millisecond)
+ }
+ }()
+ }
+ _, _ = g.SetViewOnTop(TRACE_VIEW)
+ _, _ = g.SetCurrentView(TRACE_VIEW)
+}

wuzz.go

@@ -12,6 +12,7 @@ import (
  "log"
  "mime/multipart"
  "net/http"
+ "net/http/httptrace"
  "net/url"
  "os"
  "path"
@@ -65,6 +66,7 @@ const (
  SAVE_RESULT_VIEW = "save-result"
  METHOD_LIST_VIEW = "method-list"
  HELP_VIEW = "help"
+ TRACE_VIEW = "trace"
 )
 
 var VIEW_TITLES = map[string]string{
@@ -78,6 +80,7 @@ var VIEW_TITLES = map[string]string{
  SAVE_RESULT_VIEW: "Save Result (press enter to close)",
  METHOD_LIST_VIEW: "Methods",
  HELP_VIEW: "Help",
+ TRACE_VIEW: "Trace",
 }
 
 type position struct {
@@ -312,6 +315,7 @@ var TLS_VERSIONS = map[string]uint16{
  "TLS1.0": tls.VersionTLS10,
  "TLS1.1": tls.VersionTLS11,
  "TLS1.2": tls.VersionTLS12,
+ "TLS1.3": tls.VersionTLS13,
 }
 
 var defaultEditor ViewEditor
@@ -859,6 +863,9 @@ func (a *App) SubmitRequest(g *gocui.Gui, _ *gocui.View) error {
  req.Host = headers.Get("Host")
  }
 
+ // trace http call
+ req = req.WithContext(httptrace.WithClientTrace(req.Context(), getClientTrace()))
+
  // do request
  start := time.Now()
  response, err := CLIENT.Do(req)