Documentation
¶
Overview ¶
Package redigo provides functions to trace the gomodule/redigo package (https://github.com/gomodule/redigo).
Example ¶
To start tracing Redis commands, use the TracedDial function to create a connection, passing in a service name of choice.
package main
import (
"context"
"log"
redigotrace "github.com/DataDog/dd-trace-go/v2/contrib/gomodule/redigo"
"github.com/DataDog/dd-trace-go/v2/ddtrace/tracer"
)
func main() {
c, err := redigotrace.Dial("tcp", "127.0.0.1:6379")
if err != nil {
log.Fatal(err)
}
// Emit spans per command by using your Redis connection as usual
c.Do("SET", "vehicle", "truck")
// Use a context to pass information down the call chain
root, ctx := tracer.StartSpanFromContext(context.Background(), "parent.request",
tracer.ServiceName("web"),
tracer.ResourceName("/home"),
)
// When passed a context as the final argument, c.Do will emit a span inheriting from 'parent.request'
c.Do("SET", "food", "cheese", ctx)
root.Finish()
}
Output:
Example (DialURL) ¶
Alternatively, provide a redis URL to the TracedDialURL function
package main
import (
"log"
redigotrace "github.com/DataDog/dd-trace-go/v2/contrib/gomodule/redigo"
)
func main() {
c, err := redigotrace.DialURL("redis://127.0.0.1:6379")
if err != nil {
log.Fatal(err)
}
c.Do("SET", "vehicle", "truck")
}
Output:
Example (Pool) ¶
When using a redigo Pool, set your Dial function to return a traced connection
package main
import (
redigotrace "github.com/DataDog/dd-trace-go/v2/contrib/gomodule/redigo"
"github.com/gomodule/redigo/redis"
)
func main() {
pool := &redis.Pool{
Dial: func() (redis.Conn, error) {
return redigotrace.Dial("tcp", "127.0.0.1:6379",
redigotrace.WithService("my-redis-backend"),
)
},
}
c := pool.Get()
c.Do("SET", " whiskey", " glass")
}
Output:
Example (TracedConn) ¶
package main
import (
"context"
"log"
"time"
redigotrace "github.com/DataDog/dd-trace-go/v2/contrib/gomodule/redigo"
"github.com/DataDog/dd-trace-go/v2/ddtrace/tracer"
"github.com/gomodule/redigo/redis"
)
func main() {
c, err := redigotrace.Dial("tcp", "127.0.0.1:6379",
redigotrace.WithService("my-redis-backend"),
redis.DialKeepAlive(time.Minute),
)
if err != nil {
log.Fatal(err)
}
// Emit spans per command by using your Redis connection as usual
c.Do("SET", "vehicle", "truck")
// Use a context to pass information down the call chain
root, ctx := tracer.StartSpanFromContext(context.Background(), "parent.request",
tracer.ServiceName("web"),
tracer.ResourceName("/home"),
)
// When passed a context as the final argument, c.Do will emit a span inheriting from 'parent.request'
c.Do("SET", "food", "cheese", ctx)
root.Finish()
}
Output:
Index ¶
- func Dial(network, address string, options ...interface{}) (redis.Conn, error)
- func DialContext(ctx context.Context, network, address string, options ...interface{}) (redis.Conn, error)
- func DialURL(rawurl string, options ...interface{}) (redis.Conn, error)
- type Conn
- type ConnWithContext
- type ConnWithTimeout
- type DialOption
- type DialOptionFn
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Dial ¶
Dial dials into the network address and returns a traced redis.Conn. The set of supported options must be either of type redis.DialOption or this package's DialOption.
func DialContext ¶
func DialContext(ctx context.Context, network, address string, options ...interface{}) (redis.Conn, error)
DialContext dials into the network address using redis.DialContext and returns a traced redis.Conn. The set of supported options must be either of type redis.DialOption or this package's DialOption.
func DialURL ¶
DialURL connects to a Redis server at the given URL using the Redis URI scheme. URLs should follow the draft IANA specification for the scheme (https://www.iana.org/assignments/uri-schemes/prov/redis). The returned redis.Conn is traced.
Types ¶
type Conn ¶
Conn is an implementation of the redis.Conn interface that supports tracing
func (Conn) Do ¶
Do wraps redis.Conn.Do. It sends a command to the Redis server and returns the received reply. In the process it emits a span containing key information about the command sent. When passed a context.Context as the final argument, Do will ensure that any span created inherits from this context. The rest of the arguments are passed through to the Redis server unchanged.
type ConnWithContext ¶
type ConnWithContext struct {
redis.ConnWithContext
// contains filtered or unexported fields
}
ConnWithContext is an implementation of the redis.ConnWithContext interface that supports tracing
func (ConnWithContext) Do ¶
func (tc ConnWithContext) Do(commandName string, args ...interface{}) (reply interface{}, err error)
Do wraps redis.Conn.Do. It sends a command to the Redis server and returns the received reply. In the process it emits a span containing key information about the command sent. Do will ensure that any span created inherits from the context passed as argument. The rest of the arguments are passed through to the Redis server unchanged.
func (ConnWithContext) DoContext ¶
func (tc ConnWithContext) DoContext(ctx context.Context, commandName string, args ...interface{}) (reply interface{}, err error)
DoContext wraps redis.Conn.DoContext. It sends a command to the Redis server and returns the received reply. In the process it emits a span containing key information about the command sent. Do will ensure that any span created inherits from the context passed as argument. The rest of the arguments are passed through to the Redis server unchanged.
type ConnWithTimeout ¶
type ConnWithTimeout struct {
redis.ConnWithTimeout
// contains filtered or unexported fields
}
ConnWithTimeout is an implementation of the redis.ConnWithTimeout interface that supports tracing
func (ConnWithTimeout) Do ¶
func (tc ConnWithTimeout) Do(commandName string, args ...interface{}) (reply interface{}, err error)
Do wraps redis.Conn.Do. It sends a command to the Redis server and returns the received reply. In the process it emits a span containing key information about the command sent. When passed a context.Context as the final argument, Do will ensure that any span created inherits from this context. The rest of the arguments are passed through to the Redis server unchanged.
func (ConnWithTimeout) DoWithTimeout ¶
func (tc ConnWithTimeout) DoWithTimeout(readTimeout time.Duration, commandName string, args ...interface{}) (reply interface{}, err error)
DoWithTimeout wraps redis.Conn.DoWithTimeout. It sends a command to the Redis server and returns the received reply. In the process it emits a span containing key information about the command sent. When passed a context.Context as the final argument, Do will ensure that any span created inherits from this context. The rest of the arguments are passed through to the Redis server unchanged.
type DialOption ¶
type DialOption interface {
// contains filtered or unexported methods
}
DialOption describes options for the Redis integration.
type DialOptionFn ¶
type DialOptionFn func(*dialConfig)
DialOptionFn represents options applicable to Dial, DialContext and DialURL.
func WithAnalytics ¶
func WithAnalytics(on bool) DialOptionFn
WithAnalytics enables Trace Analytics for all started spans.
func WithAnalyticsRate ¶
func WithAnalyticsRate(rate float64) DialOptionFn
WithAnalyticsRate sets the sampling rate for Trace Analytics events correlated to started spans.
func WithContextConnection ¶
func WithContextConnection() DialOptionFn
WithContextConnection wraps the connection with redis.ConnWithContext.
func WithDefaultConnection ¶
func WithDefaultConnection() DialOptionFn
WithDefaultConnection overrides the default connectionType to not be connectionTypeWithTimeout.
func WithService ¶
func WithService(name string) DialOptionFn
WithService sets the given service name for the dialled connection.
func WithTimeoutConnection ¶
func WithTimeoutConnection() DialOptionFn
WithTimeoutConnection wraps the connection with redis.ConnWithTimeout.
Source Files