Add tidwall/buntdb instrumentation

.github/dependabot.yml

@@ -102,6 +102,14 @@ updates:
     directory: "/instrumentation/github.com/syndtr/goleveldb/leveldb/splunkleveldb/test"
     schedule:
       interval: "daily"
+  - package-ecosystem: "gomod"
+    directory: "/instrumentation/github.com/tidwall/buntdb/splunkbuntdb"
+    schedule:
+      interval: "daily"
+  - package-ecosystem: "gomod"
+    directory: "/instrumentation/github.com/tidwall/buntdb/splunkbuntdb/test"
+    schedule:
+      interval: "daily"
   - package-ecosystem: "gomod"
     directory: "/instrumentation/k8s.io/client-go/splunkclient-go"
     schedule:

CHANGELOG.md

@@ -40,6 +40,10 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
   `github.com/signalfx/splunk-otel-go/instrumentation/github.com/syndtr/goleveldb/leveldb/splunkleveldb`
   instrumentation for the `github.com/syndtr/goleveldb/leveldb`
   package. (#186)
+- Add the
+  `github.com/signalfx/splunk-otel-go/instrumentation/github.com/tidwall/buntdb/splunkbuntdb`
+  instrumentation for the `github.com/tidwall/buntdb`
+  package. (#228)
 - Add the
   `github.com/signalfx/splunk-otel-go/instrumentation/k8s.io/client-go/splunkclient-go`
   instrumentation for the `k8s.io/client-go` package. (#224)

README.md

@@ -100,6 +100,7 @@ Supported libraries are listed
 
 Additional recommended Splunk specific instrumentations:
 
+- [`splunkbuntdb`](./instrumentation/github.com/tidwall/buntdb/splunkbuntdb)
 - [`splunkchi`](./instrumentation/github.com/go-chi/chi/splunkchi)
 - [`splunkclient-go`](./instrumentation/k8s.io/client-go/splunkclient-go)
 - [`splunkdns`](./instrumentation/github.com/miekg/dns/splunkdns)

build/pipeline.go

@@ -205,7 +205,7 @@ func taskGolangciLint() goyek.Task {
 			}
 
 			ForGoModules(tf, func(tf *goyek.TF) {
-				lint := tf.Cmd("golangci-lint", "run", "--timeout", "2m0s")
+				lint := tf.Cmd("golangci-lint", "run", "--timeout", "4m0s")
 				if err := lint.Run(); err != nil {
 					tf.Error(err)
 				}

instrumentation/github.com/tidwall/buntdb/splunkbuntdb/README.md

@@ -0,0 +1,11 @@
+# Splunk instrumentation for `github.com/tidwall/buntdb`
+
+This package provides OpenTelemetry instrumentation for the
+[github.com/tidwall/buntdb](https://github.com/tidwall/buntdb)
+package.
+
+## Getting Started
+
+This package is designed to be used as a drop-in replacement for the use of the
+`github.com/tidwall/buntdb` package. See
+[example_test.go](./example_test.go) for more information.

instrumentation/github.com/tidwall/buntdb/splunkbuntdb/buntdb.go

@@ -0,0 +1,329 @@
+// Copyright Splunk Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package splunkbuntdb provides instrumentation for the github.com/tidwall/buntdb
+// package.
+package splunkbuntdb
+
+import (
+	"context"
+	"time"
+
+	"github.com/tidwall/buntdb"
+	semconv "go.opentelemetry.io/otel/semconv/v1.7.0"
+	"go.opentelemetry.io/otel/trace"
+)
+
+// A DB wraps a buntdb.DB, automatically tracing any transactions.
+type DB struct {
+	*buntdb.DB
+	cfg *config
+}
+
+// Open calls buntdb.Open and wraps the result.
+func Open(path string, opts ...Option) (*DB, error) {
+	db, err := buntdb.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	return WrapDB(db, opts...), nil
+}
+
+// WrapDB wraps a buntdb.DB so it can be traced.
+func WrapDB(db *buntdb.DB, opts ...Option) *DB {
+	return &DB{
+		DB:  db,
+		cfg: newConfig(opts...),
+	}
+}
+
+// Begin calls the underlying DB.Begin and traces the transaction.
+func (db *DB) Begin(writable bool) (*Tx, error) {
+	tx, err := db.DB.Begin(writable)
+	if err != nil {
+		return nil, err
+	}
+	return WrapTx(tx, optionFunc(func(c *config) {
+		newCopy := db.cfg.copy()
+		*c = *newCopy
+	})), nil
+}
+
+// Update calls the underlying DB.Update and traces the transaction.
+func (db *DB) Update(fn func(tx *Tx) error) error {
+	return db.DB.Update(func(tx *buntdb.Tx) error {
+		return fn(WrapTx(tx, optionFunc(func(c *config) {
+			newCopy := db.cfg.copy()
+			*c = *newCopy
+		})))
+	})
+}
+
+// View calls the underlying DB.View and traces the transaction.
+func (db *DB) View(fn func(tx *Tx) error) error {
+	return db.DB.View(func(tx *buntdb.Tx) error {
+		return fn(WrapTx(tx, optionFunc(func(c *config) {
+			newCopy := db.cfg.copy()
+			*c = *newCopy
+		})))
+	})
+}
+
+// WithContext sets the context for the DB.
+func (db *DB) WithContext(ctx context.Context) *DB {
+	newdb := WrapDB(db.DB, optionFunc(func(c *config) {
+		newCopy := db.cfg.copy()
+		newCopy.ctx = ctx
+		*c = *newCopy
+	}))
+	return newdb
+}
+
+// A Tx wraps a buntdb.Tx, automatically tracing any queries.
+type Tx struct {
+	*buntdb.Tx
+	cfg *config
+}
+
+// WrapTx wraps a buntdb.Tx so it can be traced.
+func WrapTx(tx *buntdb.Tx, opts ...Option) *Tx {
+	return &Tx{
+		Tx:  tx,
+		cfg: newConfig(opts...),
+	}
+}
+
+// WithContext sets the context for the Tx.
+func (tx *Tx) WithContext(ctx context.Context) *Tx {
+	newCfg := tx.cfg.copy()
+	newCfg.ctx = ctx
+	return &Tx{
+		Tx:  tx.Tx,
+		cfg: newCfg,
+	}
+}
+
+// Ascend calls the underlying Tx.Ascend and traces the query.
+func (tx *Tx) Ascend(index string, iterator func(key, value string) bool) error {
+	return tx.cfg.withSpan("Ascend", func() error {
+		return tx.Tx.Ascend(index, iterator)
+	}, trace.WithAttributes(semconv.DBOperationKey.String("Ascend")))
+}
+
+// AscendEqual calls the underlying Tx.AscendEqual and traces the query.
+func (tx *Tx) AscendEqual(index, pivot string, iterator func(key, value string) bool) error {
+	return tx.cfg.withSpan("AscendEqual", func() error {
+		return tx.Tx.AscendEqual(index, pivot, iterator)
+	}, trace.WithAttributes(semconv.DBOperationKey.String("AscendEqual")))
+}
+
+// AscendGreaterOrEqual calls the underlying Tx.AscendGreaterOrEqual and traces the query.
+func (tx *Tx) AscendGreaterOrEqual(index, pivot string, iterator func(key, value string) bool) error {
+	return tx.cfg.withSpan("AscendGreaterOrEqual", func() error {
+		return tx.Tx.AscendGreaterOrEqual(index, pivot, iterator)
+	}, trace.WithAttributes(semconv.DBOperationKey.String("AscendGreaterOrEqual")))
+}
+
+// AscendKeys calls the underlying Tx.AscendKeys and traces the query.
+func (tx *Tx) AscendKeys(pattern string, iterator func(key, value string) bool) error {
+	return tx.cfg.withSpan("AscendKeys", func() error {
+		return tx.Tx.AscendKeys(pattern, iterator)
+	}, trace.WithAttributes(semconv.DBOperationKey.String("AscendKeys")))
+}
+
+// AscendLessThan calls the underlying Tx.AscendLessThan and traces the query.
+func (tx *Tx) AscendLessThan(index, pivot string, iterator func(key, value string) bool) error {
+	return tx.cfg.withSpan("AscendLessThan", func() error {
+		return tx.Tx.AscendLessThan(index, pivot, iterator)
+	}, trace.WithAttributes(semconv.DBOperationKey.String("AscendLessThan")))
+}
+
+// AscendRange calls the underlying Tx.AscendRange and traces the query.
+func (tx *Tx) AscendRange(index, greaterOrEqual, lessThan string, iterator func(key, value string) bool) error {
+	return tx.cfg.withSpan("AscendRange", func() error {
+		return tx.Tx.AscendRange(index, greaterOrEqual, lessThan, iterator)
+	}, trace.WithAttributes(semconv.DBOperationKey.String("AscendRange")))
+}
+
+// CreateIndex calls the underlying Tx.CreateIndex and traces the query.
+func (tx *Tx) CreateIndex(name, pattern string, less ...func(a, b string) bool) error {
+	return tx.cfg.withSpan("CreateIndex", func() error {
+		return tx.Tx.CreateIndex(name, pattern, less...)
+	}, trace.WithAttributes(semconv.DBOperationKey.String("CreateIndex")))
+}
+
+// CreateIndexOptions calls the underlying Tx.CreateIndexOptions and traces the query.
+func (tx *Tx) CreateIndexOptions(name, pattern string, opts *buntdb.IndexOptions, less ...func(a, b string) bool) error {
+	return tx.cfg.withSpan("CreateIndexOptions", func() error {
+		return tx.Tx.CreateIndexOptions(name, pattern, opts, less...)
+	}, trace.WithAttributes(semconv.DBOperationKey.String("CreateIndexOptions")))
+}
+
+// CreateSpatialIndex calls the underlying Tx.CreateSpatialIndex and traces the query.
+func (tx *Tx) CreateSpatialIndex(name, pattern string, rect func(item string) (min, max []float64)) error {
+	return tx.cfg.withSpan("CreateSpatialIndex", func() error {
+		return tx.Tx.CreateSpatialIndex(name, pattern, rect)
+	}, trace.WithAttributes(semconv.DBOperationKey.String("CreateSpatialIndex")))
+}
+
+// CreateSpatialIndexOptions calls the underlying Tx.CreateSpatialIndexOptions and traces the query.
+func (tx *Tx) CreateSpatialIndexOptions(name, pattern string, opts *buntdb.IndexOptions, rect func(item string) (min, max []float64)) error {
+	return tx.cfg.withSpan("CreateSpatialIndexOptions", func() error {
+		return tx.Tx.CreateSpatialIndexOptions(name, pattern, opts, rect)
+	}, trace.WithAttributes(semconv.DBOperationKey.String("CreateSpatialIndexOptions")))
+}
+
+// Delete calls the underlying Tx.Delete and traces the query.
+func (tx *Tx) Delete(key string) (val string, err error) {
+	err = tx.cfg.withSpan("Delete", func() error {
+		var iErr error
+		val, iErr = tx.Tx.Delete(key)
+		return iErr
+	}, trace.WithAttributes(semconv.DBOperationKey.String("Delete")))
+	return
+}
+
+// DeleteAll calls the underlying Tx.DeleteAll and traces the query.
+func (tx *Tx) DeleteAll() error {
+	return tx.cfg.withSpan("DeleteAll", func() error {
+		return tx.Tx.DeleteAll()
+	}, trace.WithAttributes(semconv.DBOperationKey.String("DeleteAll")))
+}
+
+// Descend calls the underlying Tx.Descend and traces the query.
+func (tx *Tx) Descend(index string, iterator func(key, value string) bool) error {
+	return tx.cfg.withSpan("Descend", func() error {
+		return tx.Tx.Descend(index, iterator)
+	}, trace.WithAttributes(semconv.DBOperationKey.String("Descend")))
+}
+
+// DescendEqual calls the underlying Tx.DescendEqual and traces the query.
+func (tx *Tx) DescendEqual(index, pivot string, iterator func(key, value string) bool) error {
+	return tx.cfg.withSpan("DescendEqual", func() error {
+		return tx.Tx.DescendEqual(index, pivot, iterator)
+	}, trace.WithAttributes(semconv.DBOperationKey.String("DescendEqual")))
+}
+
+// DescendGreaterThan calls the underlying Tx.DescendGreaterThan and traces the query.
+func (tx *Tx) DescendGreaterThan(index, pivot string, iterator func(key, value string) bool) error {
+	return tx.cfg.withSpan("DescendGreaterThan", func() error {
+		return tx.Tx.DescendGreaterThan(index, pivot, iterator)
+	}, trace.WithAttributes(semconv.DBOperationKey.String("DescendGreaterThan")))
+}
+
+// DescendKeys calls the underlying Tx.DescendKeys and traces the query.
+func (tx *Tx) DescendKeys(pattern string, iterator func(key, value string) bool) error {
+	return tx.cfg.withSpan("DescendKeys", func() error {
+		return tx.Tx.DescendKeys(pattern, iterator)
+	}, trace.WithAttributes(semconv.DBOperationKey.String("DescendKeys")))
+}
+
+// DescendLessOrEqual calls the underlying Tx.DescendLessOrEqual and traces the query.
+func (tx *Tx) DescendLessOrEqual(index, pivot string, iterator func(key, value string) bool) error {
+	return tx.cfg.withSpan("DescendLessOrEqual", func() error {
+		return tx.Tx.DescendLessOrEqual(index, pivot, iterator)
+	}, trace.WithAttributes(semconv.DBOperationKey.String("DescendLessOrEqual")))
+}
+
+// DescendRange calls the underlying Tx.DescendRange and traces the query.
+func (tx *Tx) DescendRange(index, lessOrEqual, greaterThan string, iterator func(key, value string) bool) error {
+	return tx.cfg.withSpan("DescendRange", func() error {
+		return tx.Tx.DescendRange(index, lessOrEqual, greaterThan, iterator)
+	}, trace.WithAttributes(semconv.DBOperationKey.String("DescendRange")))
+}
+
+// DropIndex calls the underlying Tx.DropIndex and traces the query.
+func (tx *Tx) DropIndex(name string) error {
+	return tx.cfg.withSpan("DropIndex", func() error {
+		return tx.Tx.DropIndex(name)
+	}, trace.WithAttributes(semconv.DBOperationKey.String("DropIndex")))
+}
+
+// Get calls the underlying Tx.Get and traces the query.
+func (tx *Tx) Get(key string, ignoreExpired ...bool) (val string, err error) {
+	err = tx.cfg.withSpan("Get", func() error {
+		var iErr error
+		val, iErr = tx.Tx.Get(key, ignoreExpired...)
+		return iErr
+	}, trace.WithAttributes(semconv.DBOperationKey.String("Get")))
+	return
+}
+
+// Indexes calls the underlying Tx.Indexes and traces the query.
+func (tx *Tx) Indexes() (indexes []string, err error) {
+	err = tx.cfg.withSpan("Indexes", func() error {
+		var iErr error
+		indexes, iErr = tx.Tx.Indexes()
+		return iErr
+	}, trace.WithAttributes(semconv.DBOperationKey.String("Indexes")))
+	return
+}
+
+// Intersects calls the underlying Tx.Intersects and traces the query.
+func (tx *Tx) Intersects(index, bounds string, iterator func(key, value string) bool) error {
+	return tx.cfg.withSpan("Intersects", func() error {
+		return tx.Tx.Intersects(index, bounds, iterator)
+	}, trace.WithAttributes(semconv.DBOperationKey.String("Intersects")))
+}
+
+// Len calls the underlying Tx.Len and traces the query.
+func (tx *Tx) Len() (n int, err error) {
+	err = tx.cfg.withSpan("Len", func() error {
+		var iErr error
+		n, iErr = tx.Tx.Len()
+		return iErr
+	}, trace.WithAttributes(semconv.DBOperationKey.String("Len")))
+	return
+}
+
+// Nearby calls the underlying Tx.Nearby and traces the query.
+func (tx *Tx) Nearby(index, bounds string, iterator func(key, value string, dist float64) bool) error {
+	return tx.cfg.withSpan("Nearby", func() error {
+		return tx.Tx.Nearby(index, bounds, iterator)
+	}, trace.WithAttributes(semconv.DBOperationKey.String("Nearby")))
+}
+
+// Set calls the underlying Tx.Set and traces the query.
+func (tx *Tx) Set(key, value string, opts *buntdb.SetOptions) (previousValue string, replaced bool, err error) {
+	err = tx.cfg.withSpan("Set", func() error {
+		var iErr error
+		previousValue, replaced, iErr = tx.Tx.Set(key, value, opts)
+		return iErr
+	}, trace.WithAttributes(semconv.DBOperationKey.String("Set")))
+	return
+}
+
+// TTL calls the underlying Tx.TTL and traces the query.
+func (tx *Tx) TTL(key string) (duration time.Duration, err error) {
+	err = tx.cfg.withSpan("TTL", func() error {
+		var iErr error
+		duration, iErr = tx.Tx.TTL(key)
+		return iErr
+	}, trace.WithAttributes(semconv.DBOperationKey.String("TTL")))
+	return
+}
+
+// Commit calls the underlying Tx.Commit and traces the query.
+func (tx *Tx) Commit() error {
+	return tx.cfg.withSpan("Commit", func() error {
+		return tx.Tx.Commit()
+	}, trace.WithAttributes(semconv.DBOperationKey.String("Commit")))
+}
+
+// Rollback calls the underlying Tx.Rollback and traces the query.
+func (tx *Tx) Rollback() error {
+	return tx.cfg.withSpan("Rollback", func() error {
+		return tx.Tx.Rollback()
+	}, trace.WithAttributes(semconv.DBOperationKey.String("Rollback")))
+}