Documentation
¶
Index ¶
- func AppTraceGlobalConfig()
- func Middleware(tr opentracing.Tracer, h http.Handler, options ...MWOption) http.Handler
- func MiddlewareFunc(tr opentracing.Tracer, h http.HandlerFunc, options ...MWOption) http.HandlerFunc
- type AppConfig
- type ClientOption
- type ConsulConfig
- type ConsulDiscover
- type JDSFConfig
- type MWOption
- type RegistryClient
- type TraceConfig
- type Tracer
- type Transport
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func AppTraceGlobalConfig ¶
func AppTraceGlobalConfig()
func Middleware ¶
Middleware wraps an http.Handler and traces incoming requests. Additionally, it adds the span to the request's context.
By default, the operation name of the spans is set to "HTTP {method}". This can be overriden with options.
Example:
http.ListenAndServe("localhost:80", nethttp.Middleware(tracer, http.DefaultServeMux))
The options allow fine tuning the behavior of the middleware.
Example:
mw := nethttp.Middleware(
tracer,
http.DefaultServeMux,
nethttp.OperationNameFunc(func(r *http.Request) string {
return "HTTP " + r.Method + ":/api/customers"
}),
nethttp.MWSpanObserver(func(sp opentracing.Span, r *http.Request) {
sp.SetTag("http.uri", r.URL.EscapedPath())
}),
)
func MiddlewareFunc ¶
func MiddlewareFunc(tr opentracing.Tracer, h http.HandlerFunc, options ...MWOption) http.HandlerFunc
MiddlewareFunc wraps an http.HandlerFunc and traces incoming requests. It behaves identically to the Middleware function above.
Example:
http.ListenAndServe("localhost:80", nethttp.MiddlewareFunc(tracer, MyHandler))
Types ¶
type ClientOption ¶
type ClientOption func(*clientOptions)
ClientOption contols the behavior of TraceRequest.
func ClientTrace ¶
func ClientTrace(enabled bool) ClientOption
ClientTrace returns a ClientOption that turns on or off extra instrumentation via httptrace.WithClientTrace.
func ComponentName ¶
func ComponentName(componentName string) ClientOption
ComponentName returns a ClientOption that sets the component name for the client-side span.
func OperationName ¶
func OperationName(operationName string) ClientOption
OperationName returns a ClientOption that sets the operation name for the client-side span.
type ConsulConfig ¶
type ConsulConfig struct {
Scheme string `yaml:"scheme"`
Address string `yaml:"address"`
Port int32 `yaml:"port"`
Discover *ConsulDiscover `yaml:"discover"`
}
type ConsulDiscover ¶
type JDSFConfig ¶
type JDSFConfig struct {
Consul *ConsulConfig `yaml:"consul"`
Tracing *TraceConfig `yaml:"trace"`
AppConfig *AppConfig `yaml:"app"`
}
var (
JDSFGlobalConfig *JDSFConfig
)
func NewJDSFConfig ¶
func NewJDSFConfig() *JDSFConfig
func (*JDSFConfig) LoadConfig ¶
func (j *JDSFConfig) LoadConfig(configFilePath string) *JDSFConfig
type MWOption ¶
type MWOption func(*mwOptions)
MWOption controls the behavior of the Middleware.
func MWComponentName ¶
MWComponentName returns a MWOption that sets the component name for the server-side span.
func MWSpanFilter ¶
MWSpanFilter returns a MWOption that filters requests from creating a span for the server-side span. Span won't be created if it returns false.
func MWSpanObserver ¶
MWSpanObserver returns a MWOption that observe the span for the server-side span.
type RegistryClient ¶
var (
JDSFRegistryClient *RegistryClient
)
func NewRegistryClient ¶
func NewRegistryClient() *RegistryClient
func (*RegistryClient) GetConsulClient ¶
func (r *RegistryClient) GetConsulClient() *api.Client
func (*RegistryClient) RegistryService ¶
func (r *RegistryClient) RegistryService()
func (*RegistryClient) ServiceRequestLoadBlance ¶
func (r *RegistryClient) ServiceRequestLoadBlance(rawURL string) string
type TraceConfig ¶
type TraceConfig struct {
Enable bool `yaml:"enable"`
SimpleType string `yaml:"simpleType"`
SimpleRate float64 `yaml:"simpleRate"`
TraceUdpAddress string `yaml:"traceUdpAddress"`
TraceUdpPort int `yaml:"traceUdpPort"`
TraceHttpAddress string `yaml:"traceHttpAddress"`
TraceHttpPort int `yaml:"traceHttpPort"`
}
type Tracer ¶
type Tracer struct {
Tracer opentracing.Tracer
RootSpan opentracing.Span
CurrentSpan opentracing.Span
Opts *clientOptions
}
Tracer holds tracing details for one HTTP request.
func TraceRequest ¶
func TraceRequest(tr opentracing.Tracer, req *http.Request, options ...ClientOption) (*http.Request, *Tracer)
TraceRequest adds a ClientTracer to req, tracing the request and all requests caused due to redirects. When tracing requests this way you must also use Transport.
Example:
func AskGoogle(ctx context.Context) error {
client := &http.Client{Transport: &nethttp.Transport{}}
req, err := http.NewRequest("GET", "http://google.com", nil)
if err != nil {
return err
}
req = req.WithContext(ctx) // extend existing trace, if any
req, ht := nethttp.TraceRequest(tracer, req)
defer ht.Finish()
res, err := client.Do(req)
if err != nil {
return err
}
res.Body.Close()
return nil
}
type Transport ¶
type Transport struct {
// The actual RoundTripper to use for the request. A nil
// RoundTripper defaults to http.DefaultTransport.
http.RoundTripper
}
Transport wraps a RoundTripper. If a request is being traced with Tracer, Transport will inject the current span into the headers, and set HTTP related tags on the span.
Source Files