Merge remote-tracking branch 'upstream/master' into reference

.github/ISSUE_TEMPLATE/config.yml

+blank_issues_enabled: false
+contact_links:
+ - name: Getting Help on IPFS
+   url: https://ipfs.io/help
+   about: All information about how and where to get help on IPFS.
+ - name: IPFS Official Forum
+   url: https://discuss.ipfs.io
+   about: Please post general questions, support requests, and discussions here.

.github/ISSUE_TEMPLATE/open_an_issue.md

+---
+name: Open an issue
+about: Only for actionable issues relevant to this repository.
+title: ''
+labels: need/triage
+assignees: ''
+
+---
+<!--
+Hello! To ensure this issue is correctly addressed as soon as possible by the IPFS team, please try to make sure:
+
+- This issue is relevant to this repository's topic or codebase.
+
+- A clear description is provided. It should includes as much relevant information as possible and clear scope for the issue to be actionable.
+
+FOR GENERAL DISCUSSION, HELP OR QUESTIONS, please see the options at https://ipfs.io/help or head directly to https://discuss.ipfs.io.
+
+(you can delete this section after reading)
+-->

.github/config.yml

+# Configuration for welcome - https://github.com/behaviorbot/welcome
+
+# Configuration for new-issue-welcome - https://github.com/behaviorbot/new-issue-welcome
+# Comment to be posted to on first time issues
+newIssueWelcomeComment: >
+  Thank you for submitting your first issue to this repository! A maintainer
+  will be here shortly to triage and review.
+
+  In the meantime, please double-check that you have provided all the
+  necessary information to make this process easy! Any information that can
+  help save additional round trips is useful! We currently aim to give
+  initial feedback within **two business days**. If this does not happen, feel
+  free to leave a comment.
+
+  Please keep an eye on how this issue will be labeled, as labels give an
+  overview of priorities, assignments and additional actions requested by the
+  maintainers:
+
+    - "Priority" labels will show how urgent this is for the team.
+    - "Status" labels will show if this is ready to be worked on, blocked, or in progress.
+    - "Need" labels will indicate if additional input or analysis is required.
+
+  Finally, remember to use https://discuss.ipfs.io if you just need general
+  support.
+
+# Configuration for new-pr-welcome - https://github.com/behaviorbot/new-pr-welcome
+# Comment to be posted to on PRs from first time contributors in your repository
+newPRWelcomeComment: >
+  Thank you for submitting this PR!
+
+  A maintainer will be here shortly to review it.
+
+  We are super grateful, but we are also overloaded! Help us by making sure
+  that:
+
+    * The context for this PR is clear, with relevant discussion, decisions
+      and stakeholders linked/mentioned.
+
+    * Your contribution itself is clear (code comments, self-review for the
+      rest) and in its best form. Follow the [code contribution
+      guidelines](https://github.com/ipfs/community/blob/master/CONTRIBUTING.md#code-contribution-guidelines)
+      if they apply.
+
+  Getting other community members to do a review would be great help too on
+  complex PRs (you can ask in the chats/forums). If you are unsure about
+  something, just leave us a comment.
+
+  Next steps:
+
+    * A maintainer will triage and assign priority to this PR, commenting on
+      any missing things and potentially assigning a reviewer for high
+      priority items.
+
+    * The PR gets reviews, discussed and approvals as needed.
+
+    * The PR is merged by maintainers when it has been approved and comments addressed.
+
+  We currently aim to provide initial feedback/triaging within **two business
+  days**. Please keep an eye on any labelling actions, as these will indicate
+  priorities and status of your contribution.
+
+  We are very grateful for your contribution!
+
+
+# Configuration for first-pr-merge - https://github.com/behaviorbot/first-pr-merge
+# Comment to be posted to on pull requests merged by a first time user
+# Currently disabled
+#firstPRMergeComment: ""

.gitignore

+*.swp

.gx/lastpubver

+1.4.5: QmafCXHpwUKGUrt6eQF97U1ornFxTicsw7iyYSAhu9aXgc

.travis.yml

+os:
+  - linux
+
+language: go
+
+go:
+  - 1.12.x
+
+env:
+  global:
+    - GOTFLAGS="-race"
+  matrix:
+    - BUILD_DEPTYPE=gomod
+
+
+# disable travis install
+install:
+  - true
+
+script:
+  - bash <(curl -s https://raw.githubusercontent.com/ipfs/ci-helpers/master/travis-ci/run-standard-tests.sh)
+
+
+cache:
+  directories:
+    - $GOPATH/pkg/mod
+    - $HOME/.cache/go-build
+
+notifications:
+  email: false

LICENSE

+The MIT License
+
+Copyright (c) 2016 Juan Batiz-Benet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

go.mod

+module github.com/ipfs/go-ds-measure
+
+require (
+	github.com/ipfs/go-datastore v0.4.1
+	github.com/ipfs/go-metrics-interface v0.0.1
+)
+
+go 1.12

go.sum

+github.com/go-check/check v0.0.0-20180628173108-788fd7840127 h1:0gkP6mzaMqkmpcJYCFOLkIBwI7xFExG03bbkOkCvUPI=
+github.com/go-check/check v0.0.0-20180628173108-788fd7840127/go.mod h1:9ES+weclKsC9YodN5RgxqK/VD9HM9JsCSh7rNhMZE98=
+github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
+github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/ipfs/go-datastore v0.3.0 h1:9au0tYi/+n7xeUnGHG6davnS8x9hWbOzP/388Vx3CMs=
+github.com/ipfs/go-datastore v0.3.0/go.mod h1:w38XXW9kVFNp57Zj5knbKWM2T+KOZCGDRVNdgPHtbHw=
+github.com/ipfs/go-datastore v0.3.1 h1:SS1t869a6cctoSYmZXUk8eL6AzVXgASmKIWFNQkQ1jU=
+github.com/ipfs/go-datastore v0.3.1/go.mod h1:w38XXW9kVFNp57Zj5knbKWM2T+KOZCGDRVNdgPHtbHw=
+github.com/ipfs/go-datastore v0.4.1 h1:W4ZfzyhNi3xmuU5dQhjfuRn/wFuqEE1KnOmmQiOevEY=
+github.com/ipfs/go-datastore v0.4.1/go.mod h1:SX/xMIKoCszPqp+z9JhPYCmoOoXTvaa13XEbGtsFUhA=
+github.com/ipfs/go-ipfs-delay v0.0.0-20181109222059-70721b86a9a8/go.mod h1:8SP1YXK1M1kXuc4KJZINY3TQQ03J2rwBG9QfXmbRPrw=
+github.com/ipfs/go-metrics-interface v0.0.1 h1:j+cpbjYvu4R8zbleSs36gvB7jR+wsL2fGD6n0jO4kdg=
+github.com/ipfs/go-metrics-interface v0.0.1/go.mod h1:6s6euYU4zowdslK0GKHmqaIZ3j/b/tL7HTWtJ4VPgWY=
+github.com/jbenet/goprocess v0.0.0-20160826012719-b497e2f366b8 h1:bspPhN+oKYFk5fcGNuQzp6IGzYQSenLEgH3s6jkXrWw=
+github.com/jbenet/goprocess v0.0.0-20160826012719-b497e2f366b8/go.mod h1:Ly/wlsjFq/qrU3Rar62tu1gASgGw6chQbSh/XgIIXCY=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

measure.go

+// Package measure provides a Datastore wrapper that records metrics
+// using github.com/ipfs/go-metrics-interface
+package measure
+
+import (
+	"io"
+	"time"
+
+	"github.com/ipfs/go-datastore"
+	"github.com/ipfs/go-datastore/query"
+	"github.com/ipfs/go-metrics-interface"
+)
+
+var (
+	// sort latencies in buckets with following upper bounds in seconds
+	datastoreLatencyBuckets = []float64{1e-4, 1e-3, 1e-2, 1e-1, 1}
+
+	// sort sizes in buckets with following upper bounds in bytes
+	datastoreSizeBuckets = []float64{1 << 6, 1 << 12, 1 << 18, 1 << 24}
+)
+
+// New wraps the datastore, providing metrics on the operations. The
+// metrics are registered with names starting with prefix and a dot.
+func New(prefix string, ds datastore.Datastore) *measure {
+	m := &measure{
+		backend: ds,
+
+		putNum: metrics.New(prefix+".put_total", "Total number of Datastore.Put calls").Counter(),
+		putErr: metrics.New(prefix+".put.errors_total", "Number of errored Datastore.Put calls").Counter(),
+		putLatency: metrics.New(prefix+".put.latency_seconds",
+			"Latency distribution of Datastore.Put calls").Histogram(datastoreLatencyBuckets),
+		putSize: metrics.New(prefix+".put.size_bytes",
+			"Size distribution of stored byte slices").Histogram(datastoreSizeBuckets),
+
+		syncNum: metrics.New(prefix+".sync_total", "Total number of Datastore.Sync calls").Counter(),
+		syncErr: metrics.New(prefix+".sync.errors_total", "Number of errored Datastore.Sync calls").Counter(),
+		syncLatency: metrics.New(prefix+".sync.latency_seconds",
+			"Latency distribution of Datastore.Sync calls").Histogram(datastoreLatencyBuckets),
+
+		getNum: metrics.New(prefix+".get_total", "Total number of Datastore.Get calls").Counter(),
+		getErr: metrics.New(prefix+".get.errors_total", "Number of errored Datastore.Get calls").Counter(),
+		getLatency: metrics.New(prefix+".get.latency_seconds",
+			"Latency distribution of Datastore.Get calls").Histogram(datastoreLatencyBuckets),
+		getSize: metrics.New(prefix+".get.size_bytes",
+			"Size distribution of retrieved byte slices").Histogram(datastoreSizeBuckets),
+
+		hasNum: metrics.New(prefix+".has_total", "Total number of Datastore.Has calls").Counter(),
+		hasErr: metrics.New(prefix+".has.errors_total", "Number of errored Datastore.Has calls").Counter(),
+		hasLatency: metrics.New(prefix+".has.latency_seconds",
+			"Latency distribution of Datastore.Has calls").Histogram(datastoreLatencyBuckets),
+		getsizeNum: metrics.New(prefix+".getsize_total", "Total number of Datastore.GetSize calls").Counter(),
+		getsizeErr: metrics.New(prefix+".getsize.errors_total", "Number of errored Datastore.GetSize calls").Counter(),
+		getsizeLatency: metrics.New(prefix+".getsize.latency_seconds",
+			"Latency distribution of Datastore.GetSize calls").Histogram(datastoreLatencyBuckets),
+
+		deleteNum: metrics.New(prefix+".delete_total", "Total number of Datastore.Delete calls").Counter(),
+		deleteErr: metrics.New(prefix+".delete.errors_total", "Number of errored Datastore.Delete calls").Counter(),
+		deleteLatency: metrics.New(prefix+".delete.latency_seconds",
+			"Latency distribution of Datastore.Delete calls").Histogram(datastoreLatencyBuckets),
+
+		queryNum: metrics.New(prefix+".query_total", "Total number of Datastore.Query calls").Counter(),
+		queryErr: metrics.New(prefix+".query.errors_total", "Number of errored Datastore.Query calls").Counter(),
+		queryLatency: metrics.New(prefix+".query.latency_seconds",
+			"Latency distribution of Datastore.Query calls").Histogram(datastoreLatencyBuckets),
+
+		checkNum: metrics.New(prefix+".check_total", "Total number of Datastore.Check calls").Counter(),
+		checkErr: metrics.New(prefix+".check.errors_total", "Number of errored Datastore.Check calls").Counter(),
+		checkLatency: metrics.New(prefix+".check.latency_seconds",
+			"Latency distribution of Datastore.Check calls").Histogram(datastoreLatencyBuckets),
+
+		scrubNum: metrics.New(prefix+".scrub_total", "Total number of Datastore.Scrub calls").Counter(),
+		scrubErr: metrics.New(prefix+".scrub.errors_total", "Number of errored Datastore.Scrub calls").Counter(),
+		scrubLatency: metrics.New(prefix+".scrub.latency_seconds",
+			"Latency distribution of Datastore.Scrub calls").Histogram(datastoreLatencyBuckets),
+
+		gcNum: metrics.New(prefix+".gc_total", "Total number of Datastore.CollectGarbage calls").Counter(),
+		gcErr: metrics.New(prefix+".gc.errors_total", "Number of errored Datastore.CollectGarbage calls").Counter(),
+		gcLatency: metrics.New(prefix+".gc.latency_seconds",
+			"Latency distribution of Datastore.CollectGarbage calls").Histogram(datastoreLatencyBuckets),
+
+		duNum: metrics.New(prefix+".du_total", "Total number of Datastore.DiskUsage calls").Counter(),
+		duErr: metrics.New(prefix+".du.errors_total", "Number of errored Datastore.DiskUsage calls").Counter(),
+		duLatency: metrics.New(prefix+".du.latency_seconds",
+			"Latency distribution of Datastore.DiskUsage calls").Histogram(datastoreLatencyBuckets),
+
+		batchPutNum: metrics.New(prefix+".batchput_total", "Total number of Batch.Put calls").Counter(),
+		batchPutErr: metrics.New(prefix+".batchput.errors_total", "Number of errored Batch.Put calls").Counter(),
+		batchPutLatency: metrics.New(prefix+".batchput.latency_seconds",
+			"Latency distribution of Batch.Put calls").Histogram(datastoreLatencyBuckets),
+		batchPutSize: metrics.New(prefix+".batchput.size_bytes",
+			"Size distribution of byte slices put into batches").Histogram(datastoreSizeBuckets),
+
+		batchDeleteNum: metrics.New(prefix+".batchdelete_total", "Total number of Batch.Delete calls").Counter(),
+		batchDeleteErr: metrics.New(prefix+".batchdelete.errors_total", "Number of errored Batch.Delete calls").Counter(),
+		batchDeleteLatency: metrics.New(prefix+".batchdelete.latency_seconds",
+			"Latency distribution of Batch.Delete calls").Histogram(datastoreLatencyBuckets),
+
+		batchCommitNum: metrics.New(prefix+".batchcommit_total", "Total number of Batch.Commit calls").Counter(),
+		batchCommitErr: metrics.New(prefix+".batchcommit.errors_total", "Number of errored Batch.Commit calls").Counter(),
+		batchCommitLatency: metrics.New(prefix+".batchcommit.latency_seconds",
+			"Latency distribution of Batch.Commit calls").Histogram(datastoreLatencyBuckets),
+	}
+	return m
+}
+
+type measure struct {
+	backend datastore.Datastore
+
+	putNum     metrics.Counter
+	putErr     metrics.Counter
+	putLatency metrics.Histogram
+	putSize    metrics.Histogram
+
+	syncNum     metrics.Counter
+	syncErr     metrics.Counter
+	syncLatency metrics.Histogram
+
+	getNum     metrics.Counter
+	getErr     metrics.Counter
+	getLatency metrics.Histogram
+	getSize    metrics.Histogram
+
+	hasNum     metrics.Counter
+	hasErr     metrics.Counter
+	hasLatency metrics.Histogram
+
+	getsizeNum     metrics.Counter
+	getsizeErr     metrics.Counter
+	getsizeLatency metrics.Histogram
+
+	deleteNum     metrics.Counter
+	deleteErr     metrics.Counter
+	deleteLatency metrics.Histogram
+
+	queryNum     metrics.Counter
+	queryErr     metrics.Counter
+	queryLatency metrics.Histogram
+
+	checkNum     metrics.Counter
+	checkErr     metrics.Counter
+	checkLatency metrics.Histogram
+
+	scrubNum     metrics.Counter
+	scrubErr     metrics.Counter
+	scrubLatency metrics.Histogram
+
+	gcNum     metrics.Counter
+	gcErr     metrics.Counter
+	gcLatency metrics.Histogram
+
+	duNum     metrics.Counter
+	duErr     metrics.Counter
+	duLatency metrics.Histogram
+
+	batchPutNum     metrics.Counter
+	batchPutErr     metrics.Counter
+	batchPutLatency metrics.Histogram
+	batchPutSize    metrics.Histogram
+
+	batchDeleteNum     metrics.Counter
+	batchDeleteErr     metrics.Counter
+	batchDeleteLatency metrics.Histogram
+
+	batchCommitNum     metrics.Counter
+	batchCommitErr     metrics.Counter
+	batchCommitLatency metrics.Histogram
+}
+
+func recordLatency(h metrics.Histogram, start time.Time) {
+	elapsed := time.Since(start)
+	h.Observe(elapsed.Seconds())
+}
+
+func (m *measure) Put(key datastore.Key, value []byte) error {
+	defer recordLatency(m.putLatency, time.Now())
+	m.putNum.Inc()
+	m.putSize.Observe(float64(len(value)))
+	err := m.backend.Put(key, value)
+	if err != nil {
+		m.putErr.Inc()
+	}
+	return err
+}
+
+func (m *measure) Sync(prefix datastore.Key) error {
+	defer recordLatency(m.syncLatency, time.Now())
+	m.syncNum.Inc()
+	err := m.backend.Sync(prefix)
+	if err != nil {
+		m.syncErr.Inc()
+	}
+	return err
+}
+
+func (m *measure) Get(key datastore.Key) (value []byte, err error) {
+	defer recordLatency(m.getLatency, time.Now())
+	m.getNum.Inc()
+	value, err = m.backend.Get(key)
+	switch err {
+	case nil:
+		m.getSize.Observe(float64(len(value)))
+	case datastore.ErrNotFound:
+		// Not really an error.
+	default:
+		m.getErr.Inc()
+	}
+	return value, err
+}
+
+func (m *measure) Has(key datastore.Key) (exists bool, err error) {
+	defer recordLatency(m.hasLatency, time.Now())
+	m.hasNum.Inc()
+	exists, err = m.backend.Has(key)
+	if err != nil {
+		m.hasErr.Inc()
+	}
+	return exists, err
+}
+
+func (m *measure) GetSize(key datastore.Key) (size int, err error) {
+	defer recordLatency(m.getsizeLatency, time.Now())
+	m.getsizeNum.Inc()
+	size, err = m.backend.GetSize(key)
+	switch err {
+	case nil, datastore.ErrNotFound:
+		// Not really an error.
+	default:
+		m.getsizeErr.Inc()
+	}
+	return size, err
+}
+
+func (m *measure) Delete(key datastore.Key) error {
+	defer recordLatency(m.deleteLatency, time.Now())
+	m.deleteNum.Inc()
+	err := m.backend.Delete(key)
+	if err != nil {
+		m.deleteErr.Inc()
+	}
+	return err
+}
+
+func (m *measure) Query(q query.Query) (query.Results, error) {
+	defer recordLatency(m.queryLatency, time.Now())
+	m.queryNum.Inc()
+	res, err := m.backend.Query(q)
+	if err != nil {
+		m.queryErr.Inc()
+	}
+	return res, err
+}
+
+func (m *measure) Check() error {
+	defer recordLatency(m.checkLatency, time.Now())
+	m.checkNum.Inc()
+	if c, ok := m.backend.(datastore.CheckedDatastore); ok {
+		err := c.Check()
+		if err != nil {
+			m.checkErr.Inc()
+		}
+		return err
+	}
+	return nil
+}
+
+func (m *measure) Scrub() error {
+	defer recordLatency(m.scrubLatency, time.Now())
+	m.scrubNum.Inc()
+	if c, ok := m.backend.(datastore.ScrubbedDatastore); ok {
+		err := c.Scrub()
+		if err != nil {
+			m.scrubErr.Inc()
+		}
+		return err
+	}
+	return nil
+}
+
+func (m *measure) CollectGarbage() error {
+	defer recordLatency(m.gcLatency, time.Now())
+	m.gcNum.Inc()
+	if c, ok := m.backend.(datastore.GCDatastore); ok {
+		err := c.CollectGarbage()
+		if err != nil {
+			m.gcErr.Inc()
+		}
+		return err
+	}
+	return nil
+}
+
+func (m *measure) DiskUsage() (uint64, error) {
+	defer recordLatency(m.duLatency, time.Now())
+	m.duNum.Inc()
+	size, err := datastore.DiskUsage(m.backend)
+	if err != nil {
+		m.duErr.Inc()
+	}
+	return size, err
+}
+
+type measuredBatch struct {
+	b datastore.Batch
+	m *measure
+}
+
+func (m *measure) Batch() (datastore.Batch, error) {
+	bds, ok := m.backend.(datastore.Batching)
+	if !ok {
+		return nil, datastore.ErrBatchUnsupported
+	}
+	batch, err := bds.Batch()
+	if err != nil {
+		return nil, err
+	}
+
+	return &measuredBatch{
+		b: batch,
+		m: m,
+	}, nil
+}
+
+func (mt *measuredBatch) Put(key datastore.Key, val []byte) error {
+	defer recordLatency(mt.m.batchPutLatency, time.Now())
+	mt.m.batchPutNum.Inc()
+	mt.m.batchPutSize.Observe(float64(len(val)))
+	err := mt.b.Put(key, val)
+	if err != nil {
+		mt.m.batchPutErr.Inc()
+	}
+	return err
+}
+
+func (mt *measuredBatch) Delete(key datastore.Key) error {
+	defer recordLatency(mt.m.batchDeleteLatency, time.Now())
+	mt.m.batchDeleteNum.Inc()
+	err := mt.b.Delete(key)
+	if err != nil {
+		mt.m.batchDeleteErr.Inc()
+	}
+	return err
+}
+
+func (mt *measuredBatch) Commit() error {
+	defer recordLatency(mt.m.batchCommitLatency, time.Now())
+	mt.m.batchCommitNum.Inc()
+	err := mt.b.Commit()
+	if err != nil {
+		mt.m.batchCommitErr.Inc()
+	}
+	return err
+}
+
+func (m *measure) Close() error {
+	if c, ok := m.backend.(io.Closer); ok {
+		return c.Close()
+	}
+	return nil
+}

measure_test.go

+package measure
+
+import (
+	"testing"
+
+	dstest "github.com/ipfs/go-datastore/test"
+)
+
+func TestSuite(t *testing.T) {
+	d := New("measure", dstest.NewTestDatastore(false))
+	dstest.SubtestAll(t, d)
+}