dd-trace-go.v1: gopkg.in/DataDog/dd-trace-go.v1/contrib/database/sql Index | Examples | Files | Directories

package sql

import "gopkg.in/DataDog/dd-trace-go.v1/contrib/database/sql"

Package sql provides functions to trace the database/sql package (https://golang.org/pkg/database/sql). It will automatically augment operations such as connections, statements and transactions with tracing.

We start by telling the package which driver we will be using. For example, if we are using "github.com/lib/pq", we would do as follows:

sqltrace.Register("pq", pq.Driver{})
db, err := sqltrace.Open("pq", "postgres://pqgotest:password@localhost...")

The rest of our application would continue as usual, but with tracing enabled.

Code:

// The first step is to register the driver that we will be using.
sqltrace.Register("postgres", &pq.Driver{})

// Followed by a call to Open.
db, err := sqltrace.Open("postgres", "postgres://pqgotest:password@localhost/pqgotest?sslmode=disable")
if err != nil {
    log.Fatal(err)
}

// Then, we continue using the database/sql package as we normally would, with tracing.
rows, err := db.Query("SELECT name FROM users WHERE age=?", 27)
if err != nil {
    log.Fatal(err)
}
defer rows.Close()

Code:

// Register the driver that we will be using (in this case mysql) under a custom service name.
sqltrace.Register("mysql", &mysql.MySQLDriver{}, sqltrace.WithServiceName("my-db"))

// Open a connection to the DB using the driver we've just registered with tracing.
db, err := sqltrace.Open("mysql", "user:password@/dbname")
if err != nil {
    log.Fatal(err)
}

// Create a root span, giving name, server and resource.
span, ctx := tracer.StartSpanFromContext(context.Background(), "my-query",
    tracer.SpanType(ext.SpanTypeSQL),
    tracer.ServiceName("my-db"),
    tracer.ResourceName("initial-access"),
)

// Subsequent spans inherit their parent from context.
rows, err := db.QueryContext(ctx, "SELECT * FROM city LIMIT 5")
if err != nil {
    log.Fatal(err)
}
rows.Close()
span.Finish(tracer.WithError(err))

Code:

// Register the driver that we will be using (in this case Sqlite) under a custom service name.
sqltrace.Register("sqlite", &sqlite.SQLiteDriver{}, sqltrace.WithServiceName("sqlite-example"))

// Open a connection to the DB using the driver we've just registered with tracing.
db, err := sqltrace.Open("sqlite", "./test.db")
if err != nil {
    log.Fatal(err)
}

// Create a root span, giving name, server and resource.
span, ctx := tracer.StartSpanFromContext(context.Background(), "my-query",
    tracer.SpanType("example"),
    tracer.ServiceName("sqlite-example"),
    tracer.ResourceName("initial-access"),
)

// Subsequent spans inherit their parent from context.
rows, err := db.QueryContext(ctx, "SELECT * FROM city LIMIT 5")
if err != nil {
    log.Fatal(err)
}
rows.Close()
span.Finish(tracer.WithError(err))

Index

Examples

Package Files

conn.go option.go sql.go stmt.go tx.go

func Open Uses

func Open(driverName, dataSourceName string, opts ...Option) (*sql.DB, error)

Open returns connection to a DB using a the traced version of the given driver. In order for Open to work, the driver must first be registered using Register. If this did not occur, Open will return an error.

func OpenDB Uses

func OpenDB(c driver.Connector, opts ...Option) *sql.DB

OpenDB returns connection to a DB using a the traced version of the given driver. In order for OpenDB to work, the driver must first be registered using Register. If this did not occur, OpenDB will panic.

func Register Uses

func Register(driverName string, driver driver.Driver, opts ...RegisterOption)

Register tells the sql integration package about the driver that we will be tracing. It must be called before Open, if that connection is to be traced. It uses the driverName suffixed with ".db" as the default service name.

func WithSpanTags Uses

func WithSpanTags(ctx context.Context, tags map[string]string) context.Context

WithSpanTags creates a new context containing the given set of tags. They will be added to any query created with the returned context.

type Option Uses

type Option func(*config)

Option represents an option that can be passed to Register, Open or OpenDB.

func WithAnalytics Uses

func WithAnalytics(on bool) Option

WithAnalytics enables Trace Analytics for all started spans.

func WithAnalyticsRate Uses

func WithAnalyticsRate(rate float64) Option

WithAnalyticsRate sets the sampling rate for Trace Analytics events correlated to started spans.

func WithDSN Uses

func WithDSN(name string) Option

WithDSN allows the data source name (DSN) to be provided when using OpenDB and a driver.Connector. The value is used to automatically set tags on spans.

func WithServiceName Uses

func WithServiceName(name string) Option

WithServiceName sets the given service name when registering a driver, or opening a database connection.

type RegisterOption Uses

type RegisterOption = Option

RegisterOption has been deprecated in favor of Option.

Directories

PathSynopsis
internal

Package sql imports 13 packages (graph) and is imported by 4 packages. Updated 2020-08-05. Refresh now. Tools for package owners.