非常教程

Go参考手册

net/http

net/http/httptrace

  • import "net/http/httptrace"
  • 概述
  • 索引
  • 示例

概述

httptrace包提供跟踪HTTP客户端请求中的事件的机制。

示例

package main

import (
	"fmt"
	"log"
	"net/http"
	"net/http/httptrace"
)

func main() {
	req, _ := http.NewRequest("GET", "http://example.com", nil)
	trace := &httptrace.ClientTrace{
		GotConn: func(connInfo httptrace.GotConnInfo) {
			fmt.Printf("Got Conn: %+v\n", connInfo)
		},
		DNSDone: func(dnsInfo httptrace.DNSDoneInfo) {
			fmt.Printf("DNS Info: %+v\n", dnsInfo)
		},
	}
	req = req.WithContext(httptrace.WithClientTrace(req.Context(), trace))
	_, err := http.DefaultTransport.RoundTrip(req)
	if err != nil {
		log.Fatal(err)
	}
}

索引

  • func WithClientTrace(ctx context.Context, trace *ClientTrace) context.Context
  • type ClientTrace
  • func ContextClientTrace(ctx context.Context) *ClientTrace
  • type DNSDoneInfo
  • type DNSStartInfo
  • type GotConnInfo
  • type WroteRequestInfo

示例

文件包

trace.go

func WithClientTrace(显示源文件)

func WithClientTrace(ctx context.Context, trace *ClientTrace) context.Context

WithClientTrace根据提供的父ctx返回一个新的上下文。除了使用ctx注册的任何以前的挂钩外,使用返回的上下文创建的HTTP客户端请求将使用提供的跟踪挂钩。在提供的轨迹中定义的任何钩子将首先被调用。

type ClientTrace(显示源文件)

ClientTrace是一组挂钩,可以在传出的HTTP请求的各个阶段运行。任何特定的钩子可能是零。函数可以从不同的goroutine同时调用,有些可能在请求完成或失败后调用。

ClientTrace当前在单次往返过程中跟踪单个HTTP请求和响应,并且没有跨越一系列重定向请求的挂钩。

有关更多信息,请参阅https://blog.golang.org/http-tracing。

type ClientTrace struct {
        // GetConn is called before a connection is created or
        // retrieved from an idle pool. The hostPort is the
        // "host:port" of the target or proxy. GetConn is called even
        // if there's already an idle cached connection available.
        GetConn func(hostPort string)

        // GotConn is called after a successful connection is
        // obtained. There is no hook for failure to obtain a
        // connection; instead, use the error from
        // Transport.RoundTrip.
        GotConn func(GotConnInfo)

        // PutIdleConn is called when the connection is returned to
        // the idle pool. If err is nil, the connection was
        // successfully returned to the idle pool. If err is non-nil,
        // it describes why not. PutIdleConn is not called if
        // connection reuse is disabled via Transport.DisableKeepAlives.
        // PutIdleConn is called before the caller's Response.Body.Close
        // call returns.
        // For HTTP/2, this hook is not currently used.
        PutIdleConn func(err error)

        // GotFirstResponseByte is called when the first byte of the response
        // headers is available.
        GotFirstResponseByte func()

        // Got100Continue is called if the server replies with a "100
        // Continue" response.
        Got100Continue func()

        // DNSStart is called when a DNS lookup begins.
        DNSStart func(DNSStartInfo)

        // DNSDone is called when a DNS lookup ends.
        DNSDone func(DNSDoneInfo)

        // ConnectStart is called when a new connection's Dial begins.
        // If net.Dialer.DualStack (IPv6 "Happy Eyeballs") support is
        // enabled, this may be called multiple times.
        ConnectStart func(network, addr string)

        // ConnectDone is called when a new connection's Dial
        // completes. The provided err indicates whether the
        // connection completedly successfully.
        // If net.Dialer.DualStack ("Happy Eyeballs") support is
        // enabled, this may be called multiple times.
        ConnectDone func(network, addr string, err error)

        // TLSHandshakeStart is called when the TLS handshake is started. When
        // connecting to a HTTPS site via a HTTP proxy, the handshake happens after
        // the CONNECT request is processed by the proxy.
        TLSHandshakeStart func()

        // TLSHandshakeDone is called after the TLS handshake with either the
        // successful handshake's connection state, or a non-nil error on handshake
        // failure.
        TLSHandshakeDone func(tls.ConnectionState, error)

        // WroteHeaders is called after the Transport has written
        // the request headers.
        WroteHeaders func()

        // Wait100Continue is called if the Request specified
        // "Expected: 100-continue" and the Transport has written the
        // request headers but is waiting for "100 Continue" from the
        // server before writing the request body.
        Wait100Continue func()

        // WroteRequest is called with the result of writing the
        // request and any body. It may be called multiple times
        // in the case of retried requests.
        WroteRequest func(WroteRequestInfo)
}

func ContextClientTrace(显示源文件)

func ContextClientTrace(ctx context.Context) *ClientTrace

ContextClientTrace返回与提供的上下文关联的ClientTrace。如果没有,则返回零。

type DNSDoneInfo(显示源文件)

DNSDoneInfo包含有关DNS查找结果的信息。

type DNSDoneInfo struct {
        // Addrs are the IPv4 and/or IPv6 addresses found in the DNS
        // lookup. The contents of the slice should not be mutated.
        Addrs []net.IPAddr

        // Err is any error that occurred during the DNS lookup.
        Err error

        // Coalesced is whether the Addrs were shared with another
        // caller who was doing the same DNS lookup concurrently.
        Coalesced bool
}

type DNSStartInfo(显示源文件)

DNSStartInfo包含有关DNS请求的信息。

type DNSStartInfo struct {
        Host string
}

type GotConnInfo(显示源文件)

GotConnInfo是ClientTrace.GotConn函数的参数,并包含有关获取的连接的信息。

type GotConnInfo struct {
        // Conn is the connection that was obtained. It is owned by
        // the http.Transport and should not be read, written or
        // closed by users of ClientTrace.
        Conn net.Conn

        // Reused is whether this connection has been previously
        // used for another HTTP request.
        Reused bool

        // WasIdle is whether this connection was obtained from an
        // idle pool.
        WasIdle bool

        // IdleTime reports how long the connection was previously
        // idle, if WasIdle is true.
        IdleTime time.Duration
}

type WroteRequestInfo(显示源文件)

WroteRequestInfo包含提供给WroteRequest钩子的信息。

type WroteRequestInfo struct {
        // Err is any error encountered while writing the Request.
        Err error
}
Go

Go 是一种编译型语言,它结合了解释型语言的游刃有余,动态类型语言的开发效率,以及静态类型的安全性。它也打算成为现代的,支持网络与多核计算的语言。要满足这些目标,需要解决一些语言上的问题:一个富有表达能力但轻量级的类型系统,并发与垃圾回收机制,严格的依赖规范等等。这些无法通过库或工具解决好,因此Go也就应运而生了。

主页 https://golang.org/
源码 https://go.googlesource.com/go
发布版本 1.9.2

Go目录

1.档案 | archive
2.缓冲区 | bufio
3.内置 | builtin
4.字节 | bytes
5.压缩 | compress
6.容器 | container
7.上下文 | context
8.加密 | crypto
9.数据库 | database
10.调试 | debug
11.编码 | encoding
12.错误 | errors
13. expvar
14.flag
15. fmt
16. go
17.散列 | hash
18.html
19.图像 | image
20.索引 | index
21.io
22.日志 | log
23.数学 | math
24. math/big
25.math/bits
26.math/cmplx
27.math/rand
28.拟态 | mime
29.net
30.net/http
31. net/mail
32. net/rpc
33.net/smtp
34. net/textproto
35. net/url
36.os
37.路径 | path
38.插件 | plugin
39.反射 | reflect
40.正则表达式 | regexp
41.运行时 | runtime
42.排序算法 | sort
43.转换 | strconv
44.字符串 | strings
45.同步 | sync
46.系统调用 | syscall
47.测试 | testing
48.文本 | text
49.时间戳 | time
50.unicode
51.不安全性 | unsafe
52.Go 语言数据类型
53.Go 语言基础语法
54.Go 语言结构
55.Go 语言 select 语句
56.Go 语言 switch 语句
57.Go 语言 if 语句嵌套
58.Go 语言 if…else 语句
59.Go 语言 if 语句
60.Go 语言运算符
61.Go 语言常量
62.Go 语言函数闭包
63.Go 语言函数作为实参
64.Go 语言函数引用传递值
65.Go 语言函数值传递值
66.Go 语言函数
67.Go 语言 goto 语句
68.Go 语言 continue 语句
69.Go 语言 break 语句
70.Go 语言循环嵌套
71.Go 语言 for 循环
72.Go 语言结构体
73.Go 语言指针作为函数参数
74.Go 语言指向指针的指针
75.Go 语言指针数组
76.Go 语言指针
77.Go 语言向函数传递数组
78.Go 语言多维数组
79.Go 语言变量作用域
80.Go 语言函数方法
81.Go 错误处理
82.Go 语言接口
83.Go 语言类型转换
84.Go 语言递归函数
85.Go 语言Map(集合)
86.Go 语言范围(Range)
87.Go 语言切片(Slice)
88.Go 并发
89.Go fmt.Sprintf 格式化字符串