redis

package
v1.4.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Oct 1, 2018 License: BSD-3-Clause Imports: 9 Imported by: 3

Documentation

Overview

Package redis provides tracing functions for tracing the go-redis/redis package (https://github.com/go-redis/redis).

Example

To start tracing Redis, simply create a new client using the library and continue using as you normally would.

package main

import (
	"context"

	"github.com/go-redis/redis"
	redistrace "gopkg.in/DataDog/dd-trace-go.v1/contrib/go-redis/redis"
	"gopkg.in/DataDog/dd-trace-go.v1/ddtrace/ext"
	"gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer"
)

func main() {
	// create a new Client
	opts := &redis.Options{Addr: "127.0.0.1", Password: "", DB: 0}
	c := redistrace.NewClient(opts)

	// any action emits a span
	c.Set("test_key", "test_value", 0)

	// optionally, create a new root span
	root, ctx := tracer.StartSpanFromContext(context.Background(), "parent.request",
		tracer.SpanType(ext.SpanTypeRedis),
		tracer.ServiceName("web"),
		tracer.ResourceName("/home"),
	)

	// set the context on the client
	c = c.WithContext(ctx)

	// commit further commands, which will inherit from the parent in the context.
	c.Set("food", "cheese", 0)
	root.Finish()
}
Output:

Example (Pipeliner)

You can also trace Redis Pipelines. Simply use as usual and the traces will be automatically picked up by the underlying implementation.

package main

import (
	"time"

	"github.com/go-redis/redis"
	redistrace "gopkg.in/DataDog/dd-trace-go.v1/contrib/go-redis/redis"
)

func main() {
	// create a client
	opts := &redis.Options{Addr: "127.0.0.1", Password: "", DB: 0}
	c := redistrace.NewClient(opts, redistrace.WithServiceName("my-redis-service"))

	// open the pipeline
	pipe := c.Pipeline()

	// submit some commands
	pipe.Incr("pipeline_counter")
	pipe.Expire("pipeline_counter", time.Hour)

	// execute with trace
	pipe.Exec()
}
Output:

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Client

type Client struct {
	*redis.Client
	// contains filtered or unexported fields
}

Client is used to trace requests to a redis server.

func NewClient

func NewClient(opt *redis.Options, opts ...ClientOption) *Client

NewClient returns a new Client that is traced with the default tracer under the service name "redis".

func WrapClient

func WrapClient(c *redis.Client, opts ...ClientOption) *Client

WrapClient wraps a given redis.Client with a tracer under the given service name.

func (*Client) Pipeline

func (c *Client) Pipeline() redis.Pipeliner

Pipeline creates a Pipeline from a Client

func (*Client) WithContext

func (c *Client) WithContext(ctx context.Context) *Client

WithContext sets a context on a Client. Use it to ensure that emitted spans have the correct parent.

type ClientOption

type ClientOption func(*clientConfig)

ClientOption represents an option that can be used to create or wrap a client.

func WithServiceName

func WithServiceName(name string) ClientOption

WithServiceName sets the given service name for the client.

type Pipeliner

type Pipeliner struct {
	redis.Pipeliner
	// contains filtered or unexported fields
}

Pipeliner is used to trace pipelines executed on a Redis server.

func (*Pipeliner) Exec

func (c *Pipeliner) Exec() ([]redis.Cmder, error)

Exec calls Pipeline.Exec() ensuring that the resulting Redis calls are traced.

func (*Pipeliner) ExecWithContext

func (c *Pipeliner) ExecWithContext(ctx context.Context) ([]redis.Cmder, error)

ExecWithContext calls Pipeline.Exec(). It ensures that the resulting Redis calls are traced, and that emitted spans are children of the given Context.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL