redisbp

This example shows how you can embed a redis config in a struct and parse that with `baseplate.New`.

package main

import (
	"context"

	"github.com/go-redis/redis/v7"
	"github.com/reddit/baseplate.go"
	"github.com/reddit/baseplate.go/redisbp"
)

type config struct {
	Redis redisbp.ClientConfig `yaml:"redis"`
}

// This example shows how you can embed a redis config in a struct and parse
// that with `baseplate.New`.
func main() {
	var cfg config
	ctx, bp, err := baseplate.New(context.Background(), "example.yaml", &cfg)
	if err != nil {
		panic(err)
	}
	defer bp.Close()

	factory := redisbp.NewMonitoredClientFactory(
		"redis",
		redis.NewClient(redisbp.OptionsMust(cfg.Redis.Options())),
	)
	client := factory.BuildClient(ctx)
	client.Ping()
}

This example demonstrates how to use a MonitoredCmdableFactory.

package main

import (
	"context"

	"github.com/go-redis/redis/v7"
	opentracing "github.com/opentracing/opentracing-go"
	"github.com/reddit/baseplate.go/redisbp"
	"github.com/reddit/baseplate.go/tracing"
)

// Service is an example go-kit service to help demonstrate how to use
// redisbp.type MonitoredCmdableFactory in a service.
type Service struct {
	RedisFactory redisbp.MonitoredCmdableFactory
}

// Endpoint is an example endpoint that will use redis.
func (s Service) Endpoint(ctx context.Context) error {
	// Use the factory to create a new, monitored redis client that can be
	// injected into your endpoint handler
	redis := s.RedisFactory.BuildClient(ctx)
	return EndpointHandler(ctx, redis)
}

// EndpointHandler is the actual handler function for
// Service.Endpoint.
func EndpointHandler(_ context.Context, client redisbp.MonitoredCmdable) error {
	// Any calls using the injected Redis client will be monitored using Spans.
	client.Ping()
	return nil
}

// This example demonstrates how to use a MonitoredCmdableFactory.
func main() {
	// Create a factory for basic, monitored redis.Client objects.
	clientFactory := redisbp.NewMonitoredClientFactory(
		"redis",
		redis.NewClient(&redis.Options{Addr: ":6379"}),
	)
	// Create a factory for monitored redis.Client objects that implements
	// failover with Redis Sentinel.
	failoverFactory := redisbp.NewMonitoredClientFactory(
		"redis",
		redis.NewFailoverClient(&redis.FailoverOptions{
			MasterName:    "master",
			SentinelAddrs: []string{":6379"},
		}),
	)
	// Create a factory for monitored redis.ClusterClient objects.
	clusterFactory := redisbp.NewMonitoredClusterFactory(
		"redis",
		redis.NewClusterClient(&redis.ClusterOptions{
			Addrs: []string{":7000", ":7001", ":7002"},
		}),
	)
	defer func() {
		clientFactory.Close()
		failoverFactory.Close()
		clusterFactory.Close()
	}()

	// Create a "service" with a monitored client factory.
	svc := Service{RedisFactory: clientFactory}
	// Create a server span and attach it to a context object.
	//
	// In production, this will be handled by service middleware rather than
	// being called manually.
	_, ctx := opentracing.StartSpanFromContext(
		context.Background(),
		"test",
		tracing.SpanTypeOption{Type: tracing.SpanTypeServer},
	)
	// Calls to this endpoint will use the factory to create a new client and
	// inject it into the actual implementation
	//
	// In production, the service framework will call these endpoints in
	// response to requests from clients rather than you calling it manually.
	svc.Endpoint(ctx)
}

This example demonstrates how to use SpanHook to automatically add Spans around Redis commands using go-redis

Baseplate.go also provides the MonitoredCmdableFactory object that you can use to create Redis clients with a SpanHook already attached.

// variables should be properly initialized in production code
var (
	// baseClient is not actually used to run commands, we register the Hook
	// to it and use it to create clients for each Server Span.
	baseClient redis.Client
)
// Add the Hook onto baseClient
baseClient.AddHook(redisbp.SpanHook{ClientName: "redis"})
// Create a server span and attach it into a context object
_, ctx := opentracing.StartSpanFromContext(
	context.Background(),
	"test",
	tracing.SpanTypeOption{Type: tracing.SpanTypeServer},
)
// Create a new client using the context for the server span
client := baseClient.WithContext(ctx)
// Commands should now be wrapped using Client Spans
client.Ping()