Merge branch 'master' into import-cmd-field-type-flag

2026-08-28 10:54:59 +00:00 · 2018-11-20 21:19:28 +03:00 · 2018-11-20 21:19:28 +03:00 · fd435f2806
commit fd435f2806
parent 27c222f02d e472ed3984
42 changed files with 1053 additions and 536 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@ -44,6 +44,12 @@ jobs:
    <<: *base-test
    environment:
      GOARCH: 386
+  cluster-tests:
+    <<: *defaults
+    steps:
+      - *fast-checkout
+      - setup_remote_docker
+      - run: make clustertests-build
  prerelease:
    <<: *base-test
    steps:
@ -99,6 +105,9 @@ workflows:
      - test-golang-1.10-386:
          requires:
            - build
+      - cluster-tests:
+          requires:
+            - build
      - prerelease:
          requires:
            - linter
--- a/.travis.yml
+++ b/.travis.yml
@ -1,52 +0,0 @@
-language: go
-go:
-  - "1.10" # Use string, as 1.10==1.1 if interpreted as float.
-  - master
-env:
-  global: # AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY
-    - secure: "VnBFmFfBOrrf7ONLN9WpAFCcV8SEt5G5VPnnHv97TP7PlJG8LWR6k6O+vRJOvf8V4vDMfKCTDonwWLgbssVf3yygo3C8ZoftY2phehEkWGffCgsd9ML/YBNbGq4LYLSE5HKvBqrZjQaOrVby71BAsP8W7RhC6hqzFQ00M/z8dZVfwaQQFwew2eEcSxLEaaDFS8Wgc3/UuwxDRPBq6u3cCN5RxfB+q70HvGVq4TT+0dqS4eCvz688+Z0GIGYx9olNjh0F2Kc8R2Po0lnUNa0GiHrZ21zeQ1DxIK04QABrWWmjL4h+bx3VHNKPFR4GYSKDf+pj1kfaqbfrAg6rMAJdGejgoS+QyjhgCoN4d3qRp8s+1nrxtp0TvezEdjwyxt4quGHbP5TxWUszssbGhWqf4mx6OeJ8MmdTaJjfu0f3NWJXMycqT6J73WKORk4rHeIqF9CIdxdmcpkwYj8rk0TEMTPTsd7WA8w2HIDsCz/jQnRmEgLUiNnTAofYc/uUi/Wg/T2hllkp+oBDTzxk9NTelkqx8TJ0bDmYYL9JWUi1siFHTHiVYTJgyirSfGNpe61u8OLmT0Hak/D399IfL7qgFLlMXk8q92typfO2xEduq6G+8KygeqiOMSsOY+xcDvZf5xtcEihYd21vjtrxRSqFsup/o8DIxEurQnfXBx1B+WA="
-    - secure: "U4fpHWDVOG4viqZsiVgUDW7OW1JW60uPOZy0q9pfbs86iHvmZq0PaScsZ+YdlYaN2GETVr7endDf6DCcZs1PWfg0F6VQfkOXcShX8HVS9O58lUZA5tyvbDVql9DQs4PbnkZo+ktz+Z0YaXqq2RdtMDOUz4bgZwspLPMA14if+N6w0tqCFpB7bEtpptTGsdbIQPG1n07yvSeNmK4mvrEEs77tWmhulN5iilpOqhpIvD39bJvtCYVALuJpzLd/OjLTPV9l/fl+hJkMXSj+X5ilO1DHINAcCM648iEX2phXAIWmi0O0Rbg2cI4kV9T5ysOIw8ux+YCm9bZDGTCt+VGBW5Fg+Z5iaXXexyKYCGiHleOJ7kCj9kXxh2u8NiYVNgb19dGJV5/HgQ6pcGWjeVEqr8yY1546zMjpTX+SYGQF+XZe+uggEjeAsk53ueXa0pyZTrlrqSvR7BBtWPx47s/dTg2L19FQYv3XpGMxEXLw92RplExQKi1h7QgihRxFpjGgURHhrt7d9eiNiNqBt3ZsHjmh2AkXZHnaDjlgSnFFWaMqP3UtDBWIuO+2BMbZUJVfP+gpQGBZ4gtpUSmV2JDCHgZgX5OAnLD4usxh+ATQ4rvUXF/tf8nMqEKHlGKd8hxpYSyMX21BoqfSfY4/IA0ejVE9BITqlrvqewqkP1yxe7o="
-  matrix:
-    - GOARCH=386
-    - GOARCH=386 ENTERPRISE=1
-    - GOARCH=amd64
-    - GOARCH=amd64 ENTERPRISE=1
-cache:
-  directories:
-    vendor
-install:
-  - make -B install-dep vendor
-script: make test
-jobs:
-  include:
-    - stage: metalinter
-      install:
-        - make -B install-dep vendor install-gometalinter
-      script: make gometalinter
-      env:
-        - GOARCH=amd64
-    - stage: deploy
-      script: skip
-      go: "1.10"
-      env:
-        - GOARCH=amd64
-      deploy:
-        - provider: script
-          script: pip install awscli --user `whoami` && make -B prerelease
-          skip_cleanup: true
-          on:
-            all_branches: true
-            repo: pilosa/pilosa
-            tags: false
-stages:
-  - metalinter
-  - test
-  - deploy
-matrix:
-  # Excluding or allowing failures on non-primary matrix configurations due to long running times.
-  fast_finish: true
-  allow_failures:
-    - go: master
-notifications:
-  slack:
-    secure: "SceWannxoGzeSu9PlEhl6icQFGuTmwax870k20nB2ZGYLjo77UEcwYoFwWvFsdYPa/HCo3JorMTYvMJ15VDJcnKEfzDr+kyXbHWBzUumclIOU/Im3ArEN6waQgyGbbWUQhvJjy4ATaxiOlmCyDV+KhKC9P3+WB33/OQtM3ngjAdTXYHAkfEcpeoOP75um+KsQgbi+hlnqfZdgDa6yIkFjaS3KZEJW1vmcOYYzNsXOA1Ip8j1NY6AjjWZlQorZJ/SYFqdhIv8ST3+a6cQk12u3t6TwZdcr3wmm1qmiW/SaK7UesWlT/YfElIuK8BBq9w1oZHxNKoAmLWTOe7MMisdItmtwgA14eMGl1rvNFlVf9sjsxs4AAzFvSZBZdDfx9XeLCBU5I2WUc/PKUgNQBPMVChxA7gEhtZLndsDdye7LsZASD2yYqjlVlgoZpzRexee/cJgCqUcNKDBHF39ZJYxV4KtZ0prjcSnVmLvuapplzTV4LZ+LyFapCyhiuM/oMJvxgmd7jTtFb5e5EkaHBPN1XwQWZw87yCjKsunTlTe1f1a5qoH/xvJHNpqE/jxOHU3DTLDgTxhb+FwC1Qj9a8bp+UYLw5F4P46ZnHlBGc2O74klv17EqvUMn3JhzASUtyxLGOgJulJ+o83rxJvhSiWt3GQIfkExVPzmz11641ElJI="
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -22,7 +22,7 @@ If you want to help but you aren't sure where to start, check out our [github la

 ### Development Environment

- Ensure you have a recent version of [Go](https://golang.org/doc/install) installed. Pilosa generally supports the current and previous minor versions; check our [travis file](../master/.travis.yml) for the most up-to-date information.
+- Ensure you have a recent version of [Go](https://golang.org/doc/install) installed. Pilosa generally supports the current and previous minor versions; check our [CircleCI config file](../master/.circleci/config.yml) for the most up-to-date information.

 - Make sure `$GOPATH` environment variable points to your Go working directory and `$PATH` incudes `$GOPATH/bin`, as described [here](https://golang.org/doc/code.html#GOPATH).

--- a/26
+++ b/26
@ -0,0 +1,26 @@
+# This Dockerfile is used for cluster testing - it produces a much larger image
+# and includes all of Go as well as some utilities.
+
+FROM golang:1.11
+
+LABEL maintainer "dev@pilosa.com"
+
+COPY . /go/src/github.com/pilosa/pilosa/
+
+RUN cd /go/src/github.com/pilosa/pilosa \
+    && CGO_ENABLED=0 make install-dep install FLAGS="-a"
+
+# download pumba for fault injection
+ADD https://github.com/alexei-led/pumba/releases/download/0.6.0/pumba_linux_amd64 /pumba
+RUN chmod +x /pumba
+
+RUN cp /go/bin/pilosa /pilosa
+
+COPY LICENSE /LICENSE
+COPY NOTICE /NOTICE
+
+EXPOSE 10101
+VOLUME /data
+
+ENTRYPOINT ["bash", "-c"]
+CMD ["/pilosa", "server", "--data-dir", "/data", "--bind", "http://0.0.0.0:10101"]
--- a/Gopkg.lock
+++ b/Gopkg.lock
@ -189,6 +189,15 @@
  revision = "c01d1270ff3e442a8a57cddc1c92dc1138598194"
  version = "v1.2.0"

+[[projects]]
+  name = "github.com/pilosa/go-pilosa"
+  packages = [
+    ".",
+    "gopilosa_pbuf"
+  ]
+  revision = "4e7807f5ad779407936744057cd17332046b6c3c"
+  version = "v1.1.0"
+
 [[projects]]
  name = "github.com/pkg/errors"
  packages = ["."]
@ -324,6 +333,6 @@
 [solve-meta]
  analyzer-name = "dep"
  analyzer-version = 1
-  inputs-digest = "8290156ce8b4066c46ab83d743f4c81df0a17e148415bb1ee8409a51ac4c3ba4"
+  inputs-digest = "be318fa4f2a72e7e849b2faff1ce9300deaaf2d24cf76100f4b538abed86295b"
  solver-name = "gps-cdcl"
  solver-version = 1
--- a/15
+++ b/15
@ -68,6 +68,21 @@ release: check-clean
 	$(MAKE) release-build GOOS=linux GOARCH=386
 	$(MAKE) release-build GOOS=linux GOARCH=386 ENTERPRISE=1

+# Run cluster integration tests using docker. Requires docker daemon to be
+# running. This will catch changes to internal/clustertests/*.go, but if you
+# make changes to Pilosa, you'll want to run clustertests-build to rebuild the
+# pilosa image.
+clustertests:
+	docker-compose -f internal/clustertests/docker-compose.yml down
+	docker-compose -f internal/clustertests/docker-compose.yml build client1
+	docker-compose -f internal/clustertests/docker-compose.yml up --exit-code-from=client1
+
+
+# Like clustertests, but rebuilds all images.
+clustertests-build:
+	docker-compose -f internal/clustertests/docker-compose.yml down
+	docker-compose -f internal/clustertests/docker-compose.yml up --exit-code-from=client1 --build
+
 # Create prerelease builds
 prerelease: vendor
 	$(MAKE) release-build GOOS=linux GOARCH=amd64 VERSION_ID=$$\(BRANCH_ID\)
--- a/README.md
+++ b/README.md
@ -4,7 +4,7 @@
    </a>
 </p>

-[![Build Status](https://travis-ci.org/pilosa/pilosa.svg?branch=master)](https://travis-ci.org/pilosa/pilosa)
+[![CircleCI](https://circleci.com/gh/pilosa/pilosa/tree/master.svg?style=shield)](https://circleci.com/gh/pilosa/pilosa/tree/master)
 [![GoDoc](https://godoc.org/github.com/pilosa/pilosa?status.svg)](https://godoc.org/github.com/pilosa/pilosa)
 [![Go Report Card](https://goreportcard.com/badge/github.com/pilosa/pilosa)](https://goreportcard.com/report/github.com/pilosa/pilosa)
 [![license](https://img.shields.io/github/license/pilosa/pilosa.svg)](https://github.com/pilosa/pilosa/blob/master/LICENSE)
--- a/api.go
+++ b/api.go
@ -28,6 +28,7 @@ import (

 	"github.com/pilosa/pilosa/pql"
 	"github.com/pilosa/pilosa/roaring"
+	"github.com/pilosa/pilosa/stats"
 	"github.com/pkg/errors"
 	"golang.org/x/sync/errgroup"
 )
@ -268,6 +269,10 @@ func setUpImportOptions(opts ...ImportOption) (*ImportOptions, error) {
 // of the rows in this shard of this field concatenated together in one long
 // bitmap.
 func (api *API) ImportRoaring(ctx context.Context, indexName, fieldName string, shard uint64, remote bool, data []byte, opts ...ImportOption) (err error) {
+	if len(data) == 0 {
+		return errors.New("no data to import")
+	}
+
 	if err = api.validate(apiField); err != nil {
 		return errors.Wrap(err, "validating api method")
 	}
@ -926,7 +931,7 @@ func (api *API) AvailableShardsByIndex(_ context.Context) map[string]*roaring.Bi

 // StatsWithTags returns an instance of whatever implementation of StatsClient
 // pilosa is using with the given tags.
-func (api *API) StatsWithTags(tags []string) StatsClient {
+func (api *API) StatsWithTags(tags []string) stats.StatsClient {
 	if api.holder == nil || api.cluster == nil {
 		return nil
 	}
--- a/apimethod_string.go
+++ b/apimethod_string.go
@ -4,9 +4,9 @@ package pilosa

 import "strconv"

-const _apiMethod_name = "apiClusterMessageapiCreateFieldapiCreateIndexapiDeleteFieldapiDeleteIndexapiDeleteViewapiExportCSVapiFragmentBlockDataapiFragmentBlocksapiFieldapiFieldAttrDiffapiImportapiImportValueapiIndexapiIndexAttrDiffapiQueryapiRecalculateCachesapiRemoveNodeapiResizeAbortapiSetCoordinatorapiShardNodesapiViews"
+const _apiMethod_name = "apiClusterMessageapiCreateFieldapiCreateIndexapiDeleteFieldapiDeleteAvailableShardapiDeleteIndexapiDeleteViewapiExportCSVapiFragmentBlockDataapiFragmentBlocksapiFieldapiFieldAttrDiffapiImportapiImportValueapiIndexapiIndexAttrDiffapiQueryapiRecalculateCachesapiRemoveNodeapiResizeAbortapiSetCoordinatorapiShardNodesapiViews"

-var _apiMethod_index = [...]uint16{0, 17, 31, 45, 59, 73, 86, 98, 118, 135, 143, 159, 168, 182, 190, 206, 214, 234, 247, 261, 278, 291, 299}
+var _apiMethod_index = [...]uint16{0, 17, 31, 45, 59, 82, 96, 109, 121, 141, 158, 166, 182, 191, 205, 213, 229, 237, 257, 270, 284, 301, 314, 322}

 func (i apiMethod) String() string {
 	if i < 0 || i >= apiMethod(len(_apiMethod_index)-1) {
--- a/cache.go
+++ b/cache.go
@ -23,6 +23,7 @@ import (
 	"time"

 	"github.com/pilosa/pilosa/lru"
+	"github.com/pilosa/pilosa/stats"
 )

 const (
@ -50,14 +51,14 @@ type cache interface {
 	Top() []bitmapPair

 	// SetStats defines the stats client used in the cache.
-	SetStats(s StatsClient)
+	SetStats(s stats.StatsClient)
 }

 // lruCache represents a least recently used Cache implementation.
 type lruCache struct {
 	cache  *lru.Cache
 	counts map[uint64]uint64
-	stats  StatsClient
+	stats  stats.StatsClient
 }

 // newLRUCache returns a new instance of LRUCache.
@ -65,7 +66,7 @@ func newLRUCache(maxEntries uint32) *lruCache {
 	c := &lruCache{
 		cache:  lru.New(int(maxEntries)),
 		counts: make(map[uint64]uint64),
-		stats:  NopStatsClient,
+		stats:  stats.NopStatsClient,
 	}
 	c.cache.OnEvicted = c.onEvicted
 	return c
@ -122,7 +123,7 @@ func (c *lruCache) Top() []bitmapPair {
 }

 // SetStats defines the stats client used in the cache.
-func (c *lruCache) SetStats(s StatsClient) {
+func (c *lruCache) SetStats(s stats.StatsClient) {
 	c.stats = s
 }

@ -150,7 +151,7 @@ type rankCache struct {
 	// thresholdValue is the value of the last item in the cache
 	thresholdValue uint64

-	stats StatsClient
+	stats stats.StatsClient
 }

 // NewRankCache returns a new instance of RankCache.
@ -159,7 +160,7 @@ func NewRankCache(maxEntries uint32) *rankCache {
 		maxEntries:      maxEntries,
 		thresholdBuffer: int(thresholdFactor * float64(maxEntries)),
 		entries:         make(map[uint64]uint64),
-		stats:           NopStatsClient,
+		stats:           stats.NopStatsClient,
 	}
 }

@ -279,7 +280,7 @@ func (c *rankCache) recalculate() {
 }

 // SetStats defines the stats client used in the cache.
-func (c *rankCache) SetStats(s StatsClient) {
+func (c *rankCache) SetStats(s stats.StatsClient) {
 	c.stats = s
 }

@ -458,12 +459,12 @@ func (s *simpleCache) Add(id uint64, b *Row) {

 // nopCache represents a no-op Cache implementation.
 type nopCache struct {
-	stats StatsClient
+	stats stats.StatsClient
 }

 // Ensure NopCache implements Cache.
 var globalNopCache cache = nopCache{
-	stats: NopStatsClient,
+	stats: stats.NopStatsClient,
 }

 func (c nopCache) Add(uint64, uint64)     {}
@ -471,10 +472,10 @@ func (c nopCache) BulkAdd(uint64, uint64) {}
 func (c nopCache) Get(uint64) uint64      { return 0 }
 func (c nopCache) IDs() []uint64          { return []uint64{} }

-func (c nopCache) Invalidate()          {}
-func (c nopCache) Len() int             { return 0 }
-func (c nopCache) Recalculate()         {}
-func (c nopCache) SetStats(StatsClient) {}
+func (c nopCache) Invalidate()                {}
+func (c nopCache) Len() int                   { return 0 }
+func (c nopCache) Recalculate()               {}
+func (c nopCache) SetStats(stats.StatsClient) {}

 func (c nopCache) Top() []bitmapPair {
 	return []bitmapPair{}
--- a/cluster.go
+++ b/cluster.go
@ -31,6 +31,7 @@ import (

 	"github.com/gogo/protobuf/proto"
 	"github.com/pilosa/pilosa/internal"
+	"github.com/pilosa/pilosa/logger"
 	"github.com/pilosa/pilosa/roaring"
 	"github.com/pkg/errors"
 	uuid "github.com/satori/go.uuid"
@ -65,10 +66,11 @@ type Node struct {
 	ID            string `json:"id"`
 	URI           URI    `json:"uri"`
 	IsCoordinator bool   `json:"isCoordinator"`
+	State         string `json:"state"`
 }

 func (n Node) String() string {
-	return fmt.Sprintf("Node: %s", n.ID)
+	return fmt.Sprintf("Node:%s:%s:%s", n.URI, n.State, n.ID[:6])
 }

 // Nodes represents a list of nodes.
@ -215,7 +217,7 @@ type cluster struct { // nolint: maligned
 	wg      sync.WaitGroup
 	closing chan struct{}

-	logger Logger
+	logger logger.Logger

 	InternalClient InternalClient
 }
@ -234,7 +236,7 @@ func newCluster() *cluster {

 		InternalClient: newNopInternalClient(),

-		logger: NopLogger,
+		logger: logger.NopLogger,
 	}
 }

@ -456,7 +458,19 @@ func (c *cluster) unprotectedSetState(state string) {
 	}
 }

+func (c *cluster) setMyNodeState(state string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.Node.State = state
+	for i, n := range c.nodes {
+		if n.ID == c.Node.ID {
+			c.nodes[i].State = state
+		}
+	}
+}
+
 func (c *cluster) setNodeState(state string) error { // nolint: unparam
+	c.setMyNodeState(state)
 	if c.isCoordinator() {
 		return c.receiveNodeState(c.Node.ID, state)
 	}
@ -486,11 +500,23 @@ func (c *cluster) receiveNodeState(nodeID string, state string) error {
 	}

 	c.Topology.mu.Lock()
-	c.Topology.nodeStates[nodeID] = state
+	changed := false
+	if c.Topology.nodeStates[nodeID] != state {
+		changed = true
+		c.Topology.nodeStates[nodeID] = state
+		for i, n := range c.nodes {
+			if n.ID == nodeID {
+				c.nodes[i].State = state
+			}
+		}
+	}
 	c.Topology.mu.Unlock()
 	c.logger.Printf("received state %s (%s)", state, nodeID)

-	return c.unprotectedSetStateAndBroadcast(c.determineClusterState())
+	if changed {
+		return c.unprotectedSetStateAndBroadcast(c.determineClusterState())
+	}
+	return nil
 }

 // determineClusterState is unprotected.
@ -932,7 +958,6 @@ func (c *cluster) waitForStarted() error {
 		<-c.joining
 		c.logger.Printf("joining has completed")
 	}
-
 	return nil
 }

@ -1043,8 +1068,9 @@ func (c *cluster) unprotectedSetStateAndBroadcast(state string) error {
 		return nil
 	}
 	// Broadcast cluster status changes to the cluster.
-	c.logger.Printf("broadcasting ClusterStatus: %s", state)
-	return c.broadcaster.SendSync(c.unprotectedStatus()) // TODO fix c.Status
+	status := c.unprotectedStatus()
+	c.logger.Printf("broadcasting ClusterStatus: %s", status)
+	return c.broadcaster.SendSync(status) // TODO fix c.Status

 }

@ -1354,7 +1380,7 @@ type resizeJob struct {
 	mu    sync.RWMutex
 	state string

-	Logger Logger
+	Logger logger.Logger
 }

 // newResizeJob returns a new instance of resizeJob.
@ -1386,7 +1412,7 @@ func newResizeJob(existingNodes []*Node, node *Node, action string) *resizeJob {
 		IDs:    ids,
 		action: action,
 		result: make(chan string),
-		Logger: NopLogger,
+		Logger: logger.NopLogger,
 	}
 }

@ -1625,7 +1651,7 @@ func (c *cluster) ReceiveEvent(e *NodeEvent) (err error) {

 	switch e.Event {
 	case NodeJoin:
-		c.logger.Printf("received NodeJoin event: %v", e)
+		c.logger.Printf("nodeJoin of %s on %s", e.Node.URI, c.Node.URI)
 		// Ignore the event if this is not the coordinator.
 		if !c.isCoordinator() {
 			return nil
@ -1660,6 +1686,7 @@ func (c *cluster) ReceiveEvent(e *NodeEvent) (err error) {
 func (c *cluster) nodeJoin(node *Node) error {
 	c.mu.Lock()
 	defer c.mu.Unlock()
+	c.logger.Printf("NodeJoin event on coordinator, node: %s, id: %s", node.URI, node.ID)
 	if c.needTopologyAgreement() {
 		// A host that is not part of the topology can't be added to the STARTING cluster.
 		if !c.Topology.ContainsID(node.ID) {
@ -1688,11 +1715,10 @@ func (c *cluster) nodeJoin(node *Node) error {

 		if c.haveTopologyAgreement() && c.allNodesReady() {
 			return c.unprotectedSetStateAndBroadcast(ClusterStateNormal)
-		} else {
-			// Send the status to the remote node. This lets the remote node
-			// know that it can proceed with opening its Holder.
-			return c.sendTo(node, c.unprotectedStatus())
 		}
+		// Send the status to the remote node. This lets the remote node
+		// know that it can proceed with opening its Holder.
+		return c.sendTo(node, c.unprotectedStatus())
 	}

 	// If the cluster already contains the node, just send it the cluster status.
@ -1796,6 +1822,10 @@ func (c *cluster) mergeClusterStatus(cs *ClusterStatus) error {

 	// Add all nodes from the coordinator.
 	for _, node := range officialNodes {
+		if node.ID == c.Node.ID && node.State != c.Node.State {
+			c.logger.Printf("mismatched state in mergeClusterStatus got %v have %v", node.State, c.Node.State)
+			go c.setNodeState(c.Node.State)
+		}
 		if err := c.addNode(node); err != nil {
 			return errors.Wrap(err, "adding node")
 		}
--- a/cluster_internal_test.go
+++ b/cluster_internal_test.go
@ -185,8 +185,8 @@ func TestFragSources(t *testing.T) {
 				"node0": {},
 				"node1": {},
 				"node2": {
-					{&Node{"node0", URI{"http", "host0", 10101}, false}, "i", "f", "standard", uint64(0)},
-					{&Node{"node1", URI{"http", "host1", 10101}, false}, "i", "f", "standard", uint64(2)},
+					{&Node{ID: "node0", URI: URI{"http", "host0", 10101}, IsCoordinator: false}, "i", "f", "standard", uint64(0)},
+					{&Node{ID: "node1", URI: URI{"http", "host1", 10101}, IsCoordinator: false}, "i", "f", "standard", uint64(2)},
 				},
 			},
 			err: "",
@ -197,11 +197,11 @@ func TestFragSources(t *testing.T) {
 			idx:  idx,
 			expected: map[string][]*ResizeSource{
 				"node0": {
-					{&Node{"node1", URI{"http", "host1", 10101}, false}, "i", "f", "standard", uint64(1)},
+					{&Node{ID: "node1", URI: URI{"http", "host1", 10101}, IsCoordinator: false}, "i", "f", "standard", uint64(1)},
 				},
 				"node1": {
-					{&Node{"node0", URI{"http", "host0", 10101}, false}, "i", "f", "standard", uint64(0)},
-					{&Node{"node0", URI{"http", "host0", 10101}, false}, "i", "f", "standard", uint64(2)},
+					{&Node{ID: "node0", URI: URI{"http", "host0", 10101}, IsCoordinator: false}, "i", "f", "standard", uint64(0)},
+					{&Node{ID: "node0", URI: URI{"http", "host0", 10101}, IsCoordinator: false}, "i", "f", "standard", uint64(2)},
 				},
 			},
 			err: "",
@ -212,11 +212,11 @@ func TestFragSources(t *testing.T) {
 			idx:  idx,
 			expected: map[string][]*ResizeSource{
 				"node0": {
-					{&Node{"node2", URI{"http", "host2", 10101}, false}, "i", "f", "standard", uint64(0)},
-					{&Node{"node2", URI{"http", "host2", 10101}, false}, "i", "f", "standard", uint64(2)},
+					{&Node{ID: "node2", URI: URI{"http", "host2", 10101}, IsCoordinator: false}, "i", "f", "standard", uint64(0)},
+					{&Node{ID: "node2", URI: URI{"http", "host2", 10101}, IsCoordinator: false}, "i", "f", "standard", uint64(2)},
 				},
 				"node1": {
-					{&Node{"node0", URI{"http", "host0", 10101}, false}, "i", "f", "standard", uint64(3)},
+					{&Node{ID: "node0", URI: URI{"http", "host0", 10101}, IsCoordinator: false}, "i", "f", "standard", uint64(3)},
 				},
 				"node2": {},
 			},
--- a/diagnostics.go
+++ b/diagnostics.go
@ -24,6 +24,7 @@ import (
 	"sync"
 	"time"

+	"github.com/pilosa/pilosa/logger"
 	"github.com/pkg/errors"
 )

@ -51,7 +52,7 @@ type diagnosticsCollector struct {

 	client *http.Client

-	Logger Logger
+	Logger logger.Logger

 	server *Server
 }
@ -65,7 +66,7 @@ func newDiagnosticsCollector(host string) *diagnosticsCollector { // nolint: unp
 		start:      time.Now(),
 		client:     &http.Client{Timeout: 10 * time.Second},
 		metrics:    make(map[string]interface{}),
-		Logger:     NopLogger,
+		Logger:     logger.NopLogger,
 	}
 }

--- a/encoding/proto/proto.go
+++ b/encoding/proto/proto.go
@ -506,6 +506,7 @@ func encodeNode(n *pilosa.Node) *internal.Node {
 		ID:            n.ID,
 		URI:           encodeURI(n.URI),
 		IsCoordinator: n.IsCoordinator,
+		State:         n.State,
 	}
 }

@ -761,6 +762,7 @@ func decodeNode(node *internal.Node, m *pilosa.Node) {
 	m.ID = node.ID
 	decodeURI(node.URI, &m.URI)
 	m.IsCoordinator = node.IsCoordinator
+	m.State = node.State
 }

 func decodeURI(i *internal.URI, m *pilosa.URI) {
--- a/field.go
+++ b/field.go
@ -28,8 +28,10 @@ import (

 	"github.com/gogo/protobuf/proto"
 	"github.com/pilosa/pilosa/internal"
+	"github.com/pilosa/pilosa/logger"
 	"github.com/pilosa/pilosa/pql"
 	"github.com/pilosa/pilosa/roaring"
+	"github.com/pilosa/pilosa/stats"
 	"github.com/pkg/errors"
 )

@ -69,7 +71,7 @@ type Field struct {
 	rowAttrStore AttrStore

 	broadcaster broadcaster
-	Stats       StatsClient
+	Stats       stats.StatsClient

 	// Field options.
 	options FieldOptions
@ -79,7 +81,7 @@ type Field struct {
 	// Shards with data on any node in the cluster, according to this node.
 	remoteAvailableShards *roaring.Bitmap

-	logger Logger
+	logger logger.Logger
 }

 // FieldOption is a functional option type for pilosa.fieldOptions.
@ -196,13 +198,13 @@ func newField(path, index, name string, opts FieldOption) (*Field, error) {
 		rowAttrStore: nopStore,

 		broadcaster: NopBroadcaster,
-		Stats:       NopStatsClient,
+		Stats:       stats.NopStatsClient,

 		options: applyDefaultOptions(fo),

 		remoteAvailableShards: roaring.NewBitmap(),

-		logger: NopLogger,
+		logger: logger.NopLogger,
 	}
 	return f, nil
 }
--- a/fragment.go
+++ b/fragment.go
@ -25,6 +25,7 @@ import (
 	"hash"
 	"io"
 	"io/ioutil"
+	"math"
 	"os"
 	"sort"
 	"sync"
@ -33,13 +34,12 @@ import (
 	"unsafe"

 	"github.com/cespare/xxhash"
-
-	"math"
-
 	"github.com/gogo/protobuf/proto"
 	"github.com/pilosa/pilosa/internal"
+	"github.com/pilosa/pilosa/logger"
 	"github.com/pilosa/pilosa/pql"
 	"github.com/pilosa/pilosa/roaring"
+	"github.com/pilosa/pilosa/stats"
 	"github.com/pkg/errors"
 )

@ -118,7 +118,7 @@ type fragment struct {
 	MaxOpN int

 	// Logger used for out-of-band log entries.
-	Logger Logger
+	Logger logger.Logger

 	// Row attribute storage.
 	// This is set by the parent field unless overridden for testing.
@ -128,7 +128,7 @@ type fragment struct {
 	// existing value (to clear) prior to setting a new value.
 	mutexVector vector

-	stats StatsClient
+	stats stats.StatsClient
 }

 // newFragment returns a new instance of Fragment.
@ -142,10 +142,10 @@ func newFragment(path, index, field, view string, shard uint64) *fragment {
 		CacheType: DefaultCacheType,
 		CacheSize: DefaultCacheSize,

-		Logger: NopLogger,
+		Logger: logger.NopLogger,
 		MaxOpN: defaultFragmentMaxOpN,

-		stats: NopStatsClient,
+		stats: stats.NopStatsClient,
 	}
 }

@ -1720,7 +1720,7 @@ func (f *fragment) Snapshot() error {
 	defer f.mu.Unlock()
 	return f.snapshot()
 }
-func track(start time.Time, message string, stats StatsClient, logger Logger) {
+func track(start time.Time, message string, stats stats.StatsClient, logger logger.Logger) {
 	elapsed := time.Since(start)
 	logger.Printf("%s took %s", message, elapsed)
 	stats.Histogram("snapshot", elapsed.Seconds(), 1.0)
--- a/gossip/gossip.go
+++ b/gossip/gossip.go
@ -18,6 +18,7 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"log"
 	"net"
@ -28,6 +29,7 @@ import (

 	"github.com/hashicorp/memberlist"
 	"github.com/pilosa/pilosa"
+	"github.com/pilosa/pilosa/logger"
 	"github.com/pilosa/pilosa/roaring"
 	"github.com/pilosa/pilosa/toml"
 	"github.com/pkg/errors"
@ -46,9 +48,10 @@ type memberSet struct {
 	papi   *pilosa.API
 	config *config

-	Logger pilosa.Logger
+	Logger logger.Logger

 	logger    *log.Logger
+	logOutput io.Writer
 	transport *Transport

 	eventReceiver *eventReceiver
@ -156,12 +159,19 @@ func WithLogger(logger *log.Logger) memberSetOption {
 	}
 }

+func WithLogOutput(o io.Writer) memberSetOption {
+	return func(g *memberSet) error {
+		g.logOutput = o
+		return nil
+	}
+}
+
 // NewMemberSet returns a new instance of GossipMemberSet based on options.
 func NewMemberSet(cfg Config, api *pilosa.API, options ...memberSetOption) (*memberSet, error) {
 	host := api.Node().URI.Host
 	g := &memberSet{
 		papi:   api,
-		Logger: pilosa.NopLogger,
+		Logger: logger.NopLogger,
 	}

 	// options
@ -220,7 +230,11 @@ func NewMemberSet(cfg Config, api *pilosa.API, options ...memberSetOption) (*mem
 	conf.Delegate = g
 	conf.SecretKey = gossipKey
 	conf.Events = ger
-	conf.Logger = g.logger
+	if g.logOutput != nil {
+		conf.LogOutput = g.logOutput
+	} else {
+		conf.Logger = g.logger
+	}

 	g.config = &config{
 		memberlistConfig: conf,
--- a/holder.go
+++ b/holder.go
@ -27,7 +27,9 @@ import (
 	"syscall"
 	"time"

+	"github.com/pilosa/pilosa/logger"
 	"github.com/pilosa/pilosa/roaring"
+	"github.com/pilosa/pilosa/stats"
 	"github.com/pkg/errors"
 	uuid "github.com/satori/go.uuid"
 )
@ -66,7 +68,7 @@ type Holder struct {
 	closing chan struct{}

 	// Stats
-	Stats StatsClient
+	Stats stats.StatsClient

 	// Data directory path.
 	Path string
@ -74,7 +76,7 @@ type Holder struct {
 	// The interval at which the cached row ids are persisted to disk.
 	cacheFlushInterval time.Duration

-	Logger Logger
+	Logger logger.Logger
 }

 // NewHolder returns a new instance of Holder.
@ -89,13 +91,13 @@ func NewHolder() *Holder {
 		NewPrimaryTranslateStore: newNopTranslateStore,

 		broadcaster: NopBroadcaster,
-		Stats:       NopStatsClient,
+		Stats:       stats.NopStatsClient,

 		NewAttrStore: newNopAttrStore,

 		cacheFlushInterval: defaultCacheFlushInterval,

-		Logger: NopLogger,
+		Logger: logger.NopLogger,
 	}
 }

@ -605,7 +607,7 @@ type holderSyncer struct {
 	Cluster *cluster

 	// Stats
-	Stats StatsClient
+	Stats stats.StatsClient

 	// Signals that the sync should stop.
 	Closing <-chan struct{}
--- a/http/handler.go
+++ b/http/handler.go
@ -36,6 +36,7 @@ import (
 	"github.com/gorilla/handlers"
 	"github.com/gorilla/mux"
 	"github.com/pilosa/pilosa"
+	"github.com/pilosa/pilosa/logger"

 	"github.com/pkg/errors"
 )
@ -44,7 +45,7 @@ import (
 type Handler struct {
 	Handler http.Handler

-	logger pilosa.Logger
+	logger logger.Logger

 	// Keeps the query argument validators for each handler
 	validators map[string]*queryValidationSpec
@ -95,7 +96,7 @@ func OptHandlerAPI(api *pilosa.API) handlerOption {
 	}
 }

-func OptHandlerLogger(logger pilosa.Logger) handlerOption {
+func OptHandlerLogger(logger logger.Logger) handlerOption {
 	return func(h *Handler) error {
 		h.logger = logger
 		return nil
@ -121,7 +122,7 @@ func OptHandlerCloseTimeout(d time.Duration) handlerOption {
 // NewHandler returns a new instance of Handler with a default logger.
 func NewHandler(opts ...handlerOption) (*Handler, error) {
 	handler := &Handler{
-		logger:       pilosa.NopLogger,
+		logger:       logger.NopLogger,
 		closeTimeout: time.Second * 30,
 	}
 	handler.Handler = newRouter(handler)
--- a/index.go
+++ b/index.go
@ -25,7 +25,9 @@ import (

 	"github.com/gogo/protobuf/proto"
 	"github.com/pilosa/pilosa/internal"
+	"github.com/pilosa/pilosa/logger"
 	"github.com/pilosa/pilosa/roaring"
+	"github.com/pilosa/pilosa/stats"
 	"github.com/pkg/errors"
 )

@ -49,9 +51,9 @@ type Index struct {
 	columnAttrs AttrStore

 	broadcaster broadcaster
-	Stats       StatsClient
+	Stats       stats.StatsClient

-	logger Logger
+	logger logger.Logger
 }

 // NewIndex returns a new instance of Index.
@ -70,8 +72,8 @@ func NewIndex(path, name string) (*Index, error) {
 		columnAttrs:  nopStore,

 		broadcaster:    NopBroadcaster,
-		Stats:          NopStatsClient,
-		logger:         NopLogger,
+		Stats:          stats.NopStatsClient,
+		logger:         logger.NopLogger,
 		trackExistence: true,
 	}, nil
 }
--- a/internal/clustertests/Dockerfile
+++ b/internal/clustertests/Dockerfile
@ -0,0 +1,3 @@
+FROM ptest
+
+COPY . /go/src/github.com/pilosa/pilosa/internal/clustertests
--- a/internal/clustertests/cluster_test.go
+++ b/internal/clustertests/cluster_test.go
@ -0,0 +1,81 @@
+package clustertest
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"testing"
+	"time"
+
+	"github.com/pilosa/pilosa"
+	picli "github.com/pilosa/pilosa/http"
+)
+
+func TestClusterStuff(t *testing.T) {
+	if os.Getenv("ENABLE_PILOSA_CLUSTER_TESTS") != "1" {
+		t.Skip()
+	}
+	cli, err := picli.NewInternalClient("pilosa1:10101", picli.GetHTTPClient(nil))
+	if err != nil {
+		t.Fatalf("getting client: %v", err)
+	}
+
+	t.Run("long pause", func(t *testing.T) {
+		err := cli.CreateIndex(context.Background(), "testidx", pilosa.IndexOptions{})
+		if err != nil {
+			t.Fatalf("creating index: %v", err)
+		}
+		err = cli.CreateFieldWithOptions(context.Background(), "testidx", "testf", pilosa.FieldOptions{CacheType: pilosa.CacheTypeRanked, CacheSize: 100})
+		if err != nil {
+			t.Fatalf("creating field: %v", err)
+		}
+
+		data := make([]pilosa.Bit, 10)
+		for i := 0; i < 1000; i++ {
+			data[i%10].RowID = 0
+			data[i%10].ColumnID = uint64((i/10)*pilosa.ShardWidth + i%10)
+			shard := uint64(i / 10)
+			if i%10 == 9 {
+				err = cli.Import(context.Background(), "testidx", "testf", shard, data)
+				if err != nil {
+					t.Fatalf("importing: %v", err)
+				}
+			}
+		}
+
+		r, err := cli.Query(context.Background(), "testidx", &pilosa.QueryRequest{Index: "testidx", Query: "Count(Row(testf=0))"})
+		if err != nil {
+			t.Fatalf("count querying: %v", err)
+		}
+		if r.Results[0].(uint64) != 1000 {
+			t.Fatalf("count after import is %d", r.Results[0].(uint64))
+		}
+
+		pcmd := exec.Command("/pumba", "pause", "clustertests_pilosa3_1", "--duration", "10s")
+		pcmd.Stdout = os.Stdout
+		pcmd.Stderr = os.Stderr
+		t.Log("pausing pilosa3 for 10s")
+		err = pcmd.Start()
+		if err != nil {
+			t.Fatalf("starting pumba command: %v", err)
+		}
+		err = pcmd.Wait()
+		if err != nil {
+			t.Fatalf("waiting on pumba pause cmd: %v", err)
+		}
+
+		// TODO change the sleep to wait for status to return to NORMAL - need support in internal client for getting status
+		t.Log("done with pause, waiting for stability")
+		time.Sleep(time.Second * 3)
+		t.Log("done waiting for stability")
+
+		r, err = cli.Query(context.Background(), "testidx", &pilosa.QueryRequest{Index: "testidx", Query: "Count(Row(testf=0))"})
+		if err != nil {
+			t.Fatalf("count querying: %v", err)
+		}
+		if r.Results[0].(uint64) != 1000 {
+			t.Fatalf("count after import is %d", r.Results[0].(uint64))
+		}
+	})
+
+}
--- a/internal/clustertests/docker-compose.yml
+++ b/internal/clustertests/docker-compose.yml
@ -0,0 +1,55 @@
+version: '2'
+services: 
+  pilosa1:
+    build:
+      context: ../..
+      dockerfile: Dockerfile-clustertests
+    image: ptest
+    ports:
+      - "33455:10101"
+    environment:
+      - PILOSA_CLUSTER_COORDINATOR=true
+      - PILOSA_GOSSIP_SEEDS=pilosa1:14000
+    networks:
+      - pilosanet
+    command:
+      - "/pilosa server --bind pilosa1:10101"
+  pilosa2:
+    build:
+      context: ../..
+      dockerfile: Dockerfile-clustertests
+    image: ptest
+    ports:
+      - "33456:10101"
+    environment:
+      - PILOSA_GOSSIP_SEEDS=pilosa1:14000
+    networks:
+      - pilosanet
+    command:
+      - "/pilosa server --bind pilosa2:10101"
+  pilosa3:
+    build:
+      context: ../..
+      dockerfile: Dockerfile-clustertests
+    image: ptest
+    ports:
+      - "33457:10101"
+    environment:
+      - PILOSA_GOSSIP_SEEDS=pilosa1:14000,pilosa2:14000
+    networks:
+      - pilosanet
+    command:
+      - "/pilosa server --bind pilosa3:10101"
+  client1:
+    build:
+      context: .
+    environment:
+      - ENABLE_PILOSA_CLUSTER_TESTS=1
+    networks:
+      - pilosanet
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+    command:
+      - "go test -v -count=1 github.com/pilosa/pilosa/internal/clustertests"
+networks: 
+  pilosanet:
--- a/internal/private.pb.go
+++ b/internal/private.pb.go
@ -32,7 +32,7 @@ func (m *IndexMeta) Reset()         { *m = IndexMeta{} }
 func (m *IndexMeta) String() string { return proto.CompactTextString(m) }
 func (*IndexMeta) ProtoMessage()    {}
 func (*IndexMeta) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{0}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{0}
 }
 func (m *IndexMeta) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -92,7 +92,7 @@ func (m *FieldOptions) Reset()         { *m = FieldOptions{} }
 func (m *FieldOptions) String() string { return proto.CompactTextString(m) }
 func (*FieldOptions) ProtoMessage()    {}
 func (*FieldOptions) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{1}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{1}
 }
 func (m *FieldOptions) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -181,7 +181,7 @@ func (m *ImportResponse) Reset()         { *m = ImportResponse{} }
 func (m *ImportResponse) String() string { return proto.CompactTextString(m) }
 func (*ImportResponse) ProtoMessage()    {}
 func (*ImportResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{2}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{2}
 }
 func (m *ImportResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -232,7 +232,7 @@ func (m *BlockDataRequest) Reset()         { *m = BlockDataRequest{} }
 func (m *BlockDataRequest) String() string { return proto.CompactTextString(m) }
 func (*BlockDataRequest) ProtoMessage()    {}
 func (*BlockDataRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{3}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{3}
 }
 func (m *BlockDataRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -308,7 +308,7 @@ func (m *BlockDataResponse) Reset()         { *m = BlockDataResponse{} }
 func (m *BlockDataResponse) String() string { return proto.CompactTextString(m) }
 func (*BlockDataResponse) ProtoMessage()    {}
 func (*BlockDataResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{4}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{4}
 }
 func (m *BlockDataResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -362,7 +362,7 @@ func (m *Cache) Reset()         { *m = Cache{} }
 func (m *Cache) String() string { return proto.CompactTextString(m) }
 func (*Cache) ProtoMessage()    {}
 func (*Cache) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{5}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{5}
 }
 func (m *Cache) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -409,7 +409,7 @@ func (m *MaxShards) Reset()         { *m = MaxShards{} }
 func (m *MaxShards) String() string { return proto.CompactTextString(m) }
 func (*MaxShards) ProtoMessage()    {}
 func (*MaxShards) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{6}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{6}
 }
 func (m *MaxShards) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -458,7 +458,7 @@ func (m *CreateShardMessage) Reset()         { *m = CreateShardMessage{} }
 func (m *CreateShardMessage) String() string { return proto.CompactTextString(m) }
 func (*CreateShardMessage) ProtoMessage()    {}
 func (*CreateShardMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{7}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{7}
 }
 func (m *CreateShardMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -519,7 +519,7 @@ func (m *DeleteIndexMessage) Reset()         { *m = DeleteIndexMessage{} }
 func (m *DeleteIndexMessage) String() string { return proto.CompactTextString(m) }
 func (*DeleteIndexMessage) ProtoMessage()    {}
 func (*DeleteIndexMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{8}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{8}
 }
 func (m *DeleteIndexMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -567,7 +567,7 @@ func (m *CreateIndexMessage) Reset()         { *m = CreateIndexMessage{} }
 func (m *CreateIndexMessage) String() string { return proto.CompactTextString(m) }
 func (*CreateIndexMessage) ProtoMessage()    {}
 func (*CreateIndexMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{9}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{9}
 }
 func (m *CreateIndexMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -623,7 +623,7 @@ func (m *CreateFieldMessage) Reset()         { *m = CreateFieldMessage{} }
 func (m *CreateFieldMessage) String() string { return proto.CompactTextString(m) }
 func (*CreateFieldMessage) ProtoMessage()    {}
 func (*CreateFieldMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{10}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{10}
 }
 func (m *CreateFieldMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -685,7 +685,7 @@ func (m *DeleteFieldMessage) Reset()         { *m = DeleteFieldMessage{} }
 func (m *DeleteFieldMessage) String() string { return proto.CompactTextString(m) }
 func (*DeleteFieldMessage) ProtoMessage()    {}
 func (*DeleteFieldMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{11}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{11}
 }
 func (m *DeleteFieldMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -741,7 +741,7 @@ func (m *DeleteAvailableShardMessage) Reset()         { *m = DeleteAvailableShar
 func (m *DeleteAvailableShardMessage) String() string { return proto.CompactTextString(m) }
 func (*DeleteAvailableShardMessage) ProtoMessage()    {}
 func (*DeleteAvailableShardMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{12}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{12}
 }
 func (m *DeleteAvailableShardMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -804,7 +804,7 @@ func (m *Field) Reset()         { *m = Field{} }
 func (m *Field) String() string { return proto.CompactTextString(m) }
 func (*Field) ProtoMessage()    {}
 func (*Field) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{13}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{13}
 }
 func (m *Field) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -865,7 +865,7 @@ func (m *Schema) Reset()         { *m = Schema{} }
 func (m *Schema) String() string { return proto.CompactTextString(m) }
 func (*Schema) ProtoMessage()    {}
 func (*Schema) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{14}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{14}
 }
 func (m *Schema) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -913,7 +913,7 @@ func (m *Index) Reset()         { *m = Index{} }
 func (m *Index) String() string { return proto.CompactTextString(m) }
 func (*Index) ProtoMessage()    {}
 func (*Index) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{15}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{15}
 }
 func (m *Index) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -969,7 +969,7 @@ func (m *URI) Reset()         { *m = URI{} }
 func (m *URI) String() string { return proto.CompactTextString(m) }
 func (*URI) ProtoMessage()    {}
 func (*URI) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{16}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{16}
 }
 func (m *URI) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1023,6 +1023,7 @@ type Node struct {
 	ID                   string   `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
 	URI                  *URI     `protobuf:"bytes,2,opt,name=URI" json:"URI,omitempty"`
 	IsCoordinator        bool     `protobuf:"varint,3,opt,name=IsCoordinator,proto3" json:"IsCoordinator,omitempty"`
+	State                string   `protobuf:"bytes,4,opt,name=State,proto3" json:"State,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@ -1032,7 +1033,7 @@ func (m *Node) Reset()         { *m = Node{} }
 func (m *Node) String() string { return proto.CompactTextString(m) }
 func (*Node) ProtoMessage()    {}
 func (*Node) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{17}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{17}
 }
 func (m *Node) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1082,6 +1083,13 @@ func (m *Node) GetIsCoordinator() bool {
 	return false
 }

+func (m *Node) GetState() string {
+	if m != nil {
+		return m.State
+	}
+	return ""
+}
+
 type NodeStateMessage struct {
 	NodeID               string   `protobuf:"bytes,1,opt,name=NodeID,proto3" json:"NodeID,omitempty"`
 	State                string   `protobuf:"bytes,2,opt,name=State,proto3" json:"State,omitempty"`
@ -1094,7 +1102,7 @@ func (m *NodeStateMessage) Reset()         { *m = NodeStateMessage{} }
 func (m *NodeStateMessage) String() string { return proto.CompactTextString(m) }
 func (*NodeStateMessage) ProtoMessage()    {}
 func (*NodeStateMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{18}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{18}
 }
 func (m *NodeStateMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1149,7 +1157,7 @@ func (m *NodeEventMessage) Reset()         { *m = NodeEventMessage{} }
 func (m *NodeEventMessage) String() string { return proto.CompactTextString(m) }
 func (*NodeEventMessage) ProtoMessage()    {}
 func (*NodeEventMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{19}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{19}
 }
 func (m *NodeEventMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1205,7 +1213,7 @@ func (m *NodeStatus) Reset()         { *m = NodeStatus{} }
 func (m *NodeStatus) String() string { return proto.CompactTextString(m) }
 func (*NodeStatus) ProtoMessage()    {}
 func (*NodeStatus) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{20}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{20}
 }
 func (m *NodeStatus) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1267,7 +1275,7 @@ func (m *IndexStatus) Reset()         { *m = IndexStatus{} }
 func (m *IndexStatus) String() string { return proto.CompactTextString(m) }
 func (*IndexStatus) ProtoMessage()    {}
 func (*IndexStatus) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{21}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{21}
 }
 func (m *IndexStatus) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1322,7 +1330,7 @@ func (m *FieldStatus) Reset()         { *m = FieldStatus{} }
 func (m *FieldStatus) String() string { return proto.CompactTextString(m) }
 func (*FieldStatus) ProtoMessage()    {}
 func (*FieldStatus) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{22}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{22}
 }
 func (m *FieldStatus) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1378,7 +1386,7 @@ func (m *ClusterStatus) Reset()         { *m = ClusterStatus{} }
 func (m *ClusterStatus) String() string { return proto.CompactTextString(m) }
 func (*ClusterStatus) ProtoMessage()    {}
 func (*ClusterStatus) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{23}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{23}
 }
 func (m *ClusterStatus) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1442,7 +1450,7 @@ func (m *BSIGroup) Reset()         { *m = BSIGroup{} }
 func (m *BSIGroup) String() string { return proto.CompactTextString(m) }
 func (*BSIGroup) ProtoMessage()    {}
 func (*BSIGroup) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{24}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{24}
 }
 func (m *BSIGroup) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1512,7 +1520,7 @@ func (m *CreateViewMessage) Reset()         { *m = CreateViewMessage{} }
 func (m *CreateViewMessage) String() string { return proto.CompactTextString(m) }
 func (*CreateViewMessage) ProtoMessage()    {}
 func (*CreateViewMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{25}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{25}
 }
 func (m *CreateViewMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1575,7 +1583,7 @@ func (m *DeleteViewMessage) Reset()         { *m = DeleteViewMessage{} }
 func (m *DeleteViewMessage) String() string { return proto.CompactTextString(m) }
 func (*DeleteViewMessage) ProtoMessage()    {}
 func (*DeleteViewMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{26}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{26}
 }
 func (m *DeleteViewMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1641,7 +1649,7 @@ func (m *ResizeInstruction) Reset()         { *m = ResizeInstruction{} }
 func (m *ResizeInstruction) String() string { return proto.CompactTextString(m) }
 func (*ResizeInstruction) ProtoMessage()    {}
 func (*ResizeInstruction) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{27}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{27}
 }
 func (m *ResizeInstruction) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1727,7 +1735,7 @@ func (m *ResizeSource) Reset()         { *m = ResizeSource{} }
 func (m *ResizeSource) String() string { return proto.CompactTextString(m) }
 func (*ResizeSource) ProtoMessage()    {}
 func (*ResizeSource) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{28}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{28}
 }
 func (m *ResizeSource) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1804,7 +1812,7 @@ func (m *ResizeInstructionComplete) Reset()         { *m = ResizeInstructionComp
 func (m *ResizeInstructionComplete) String() string { return proto.CompactTextString(m) }
 func (*ResizeInstructionComplete) ProtoMessage()    {}
 func (*ResizeInstructionComplete) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{29}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{29}
 }
 func (m *ResizeInstructionComplete) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1865,7 +1873,7 @@ func (m *SetCoordinatorMessage) Reset()         { *m = SetCoordinatorMessage{} }
 func (m *SetCoordinatorMessage) String() string { return proto.CompactTextString(m) }
 func (*SetCoordinatorMessage) ProtoMessage()    {}
 func (*SetCoordinatorMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{30}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{30}
 }
 func (m *SetCoordinatorMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1912,7 +1920,7 @@ func (m *UpdateCoordinatorMessage) Reset()         { *m = UpdateCoordinatorMessa
 func (m *UpdateCoordinatorMessage) String() string { return proto.CompactTextString(m) }
 func (*UpdateCoordinatorMessage) ProtoMessage()    {}
 func (*UpdateCoordinatorMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{31}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{31}
 }
 func (m *UpdateCoordinatorMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -1960,7 +1968,7 @@ func (m *Topology) Reset()         { *m = Topology{} }
 func (m *Topology) String() string { return proto.CompactTextString(m) }
 func (*Topology) ProtoMessage()    {}
 func (*Topology) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{32}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{32}
 }
 func (m *Topology) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -2013,7 +2021,7 @@ func (m *RecalculateCaches) Reset()         { *m = RecalculateCaches{} }
 func (m *RecalculateCaches) String() string { return proto.CompactTextString(m) }
 func (*RecalculateCaches) ProtoMessage()    {}
 func (*RecalculateCaches) Descriptor() ([]byte, []int) {
-	return fileDescriptor_private_ef0da41f92e2513d, []int{33}
+	return fileDescriptor_private_725d4d7695f6ae76, []int{33}
 }
 func (m *RecalculateCaches) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -2809,6 +2817,12 @@ func (m *Node) MarshalTo(dAtA []byte) (int, error) {
 		}
 		i++
 	}
+	if len(m.State) > 0 {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintPrivate(dAtA, i, uint64(len(m.State)))
+		i += copy(dAtA[i:], m.State)
+	}
 	if m.XXX_unrecognized != nil {
 		i += copy(dAtA[i:], m.XXX_unrecognized)
 	}
@ -3891,6 +3905,10 @@ func (m *Node) Size() (n int) {
 	if m.IsCoordinator {
 		n += 2
 	}
+	l = len(m.State)
+	if l > 0 {
+		n += 1 + l + sovPrivate(uint64(l))
+	}
 	if m.XXX_unrecognized != nil {
 		n += len(m.XXX_unrecognized)
 	}
@ -6592,6 +6610,35 @@ func (m *Node) Unmarshal(dAtA []byte) error {
 				}
 			}
 			m.IsCoordinator = bool(v != 0)
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPrivate
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthPrivate
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.State = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipPrivate(dAtA[iNdEx:])
@ -8789,78 +8836,79 @@ var (
 	ErrIntOverflowPrivate   = fmt.Errorf("proto: integer overflow")
 )

-func init() { proto.RegisterFile("private.proto", fileDescriptor_private_ef0da41f92e2513d) }
+func init() { proto.RegisterFile("private.proto", fileDescriptor_private_725d4d7695f6ae76) }

-var fileDescriptor_private_ef0da41f92e2513d = []byte{
-	// 1113 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xdb, 0x6e, 0x1b, 0x45,
-	0x18, 0x66, 0x0f, 0x76, 0xec, 0xdf, 0x75, 0x9a, 0x6c, 0x69, 0xd9, 0x02, 0x0a, 0x61, 0x54, 0xd1,
-	0x50, 0x89, 0x50, 0xb5, 0x37, 0x9c, 0x2a, 0x95, 0xc4, 0xa1, 0x2c, 0x25, 0xa5, 0xcc, 0xa6, 0xb9,
-	0xeb, 0xc5, 0xc4, 0x1e, 0x35, 0xab, 0xac, 0x77, 0xcc, 0xee, 0x6c, 0x12, 0xf7, 0x82, 0x5b, 0x90,
-	0x78, 0x01, 0xc4, 0x93, 0xf0, 0x08, 0x5c, 0xf2, 0x08, 0x28, 0xbc, 0x08, 0x9a, 0x7f, 0x66, 0x76,
-	0x37, 0x8e, 0x43, 0xa2, 0xc0, 0xdd, 0xfc, 0xdf, 0x7f, 0x3e, 0xae, 0x0d, 0xfd, 0x49, 0x9e, 0x1c,
-	0x32, 0xc9, 0xd7, 0x27, 0xb9, 0x90, 0x22, 0xe8, 0x24, 0x99, 0xe4, 0x79, 0xc6, 0x52, 0xf2, 0x04,
-	0xba, 0x51, 0x36, 0xe2, 0xc7, 0xdb, 0x5c, 0xb2, 0x20, 0x00, 0xff, 0x29, 0x9f, 0x16, 0xa1, 0xb7,
-	0xea, 0xac, 0x75, 0x28, 0xbe, 0x83, 0x0f, 0x60, 0x71, 0x27, 0x67, 0xc3, 0x83, 0xad, 0xe3, 0xa4,
-	0x90, 0x3c, 0x1b, 0xf2, 0xd0, 0x47, 0xee, 0x0c, 0x4a, 0x7e, 0x77, 0xe0, 0xda, 0x57, 0x09, 0x4f,
-	0x47, 0xdf, 0x4d, 0x64, 0x22, 0xb2, 0x22, 0x78, 0x17, 0xba, 0x9b, 0x6c, 0xb8, 0xcf, 0x77, 0xa6,
-	0x13, 0x8e, 0x16, 0xbb, 0xb4, 0x06, 0x2a, 0x6e, 0x9c, 0xbc, 0xd6, 0x16, 0xfb, 0xb4, 0x06, 0x82,
-	0x55, 0xe8, 0xed, 0x24, 0x63, 0xfe, 0x7d, 0xc9, 0x32, 0x59, 0x8e, 0xc3, 0x16, 0x6a, 0x37, 0x21,
-	0x15, 0x2a, 0x1a, 0xee, 0x20, 0x0b, 0xdf, 0xc1, 0x12, 0x78, 0xdb, 0x49, 0x16, 0x76, 0x57, 0x9d,
-	0x35, 0x8f, 0xaa, 0x27, 0x22, 0xec, 0x38, 0x04, 0x83, 0xb0, 0xe3, 0x2a, 0xc5, 0x5e, 0x9d, 0x22,
-	0x21, 0xb0, 0x18, 0x8d, 0x27, 0x22, 0x97, 0x94, 0x17, 0x13, 0x91, 0x15, 0x68, 0x69, 0x2b, 0xcf,
-	0x43, 0x07, 0x8d, 0xab, 0x27, 0xf9, 0x11, 0x96, 0x36, 0x52, 0x31, 0x3c, 0x18, 0x30, 0xc9, 0x28,
-	0xff, 0xa1, 0xe4, 0x85, 0x0c, 0xde, 0x84, 0x16, 0xd6, 0xce, 0xc8, 0x69, 0x42, 0xa1, 0x58, 0x87,
-	0xd0, 0xd5, 0x28, 0x12, 0x0a, 0x45, 0x7d, 0xac, 0x84, 0x4f, 0x35, 0xa1, 0xd0, 0x78, 0x9f, 0xe5,
-	0x23, 0xac, 0x80, 0x4f, 0x35, 0xa1, 0x62, 0xdc, 0x4d, 0xf8, 0x91, 0x49, 0x1b, 0xdf, 0x24, 0x82,
-	0xe5, 0x86, 0x7f, 0x13, 0xe6, 0x2d, 0x68, 0x53, 0x71, 0x14, 0x0d, 0x8a, 0xd0, 0x59, 0xf5, 0xd6,
-	0x7c, 0x6a, 0x28, 0x2c, 0xae, 0x48, 0xcb, 0x71, 0xa6, 0x58, 0x2e, 0xb2, 0x6a, 0x80, 0xdc, 0x86,
-	0x16, 0x56, 0x5a, 0x65, 0x59, 0xeb, 0xaa, 0x27, 0xf9, 0xc9, 0x81, 0xee, 0x36, 0x3b, 0xc6, 0x30,
-	0x8a, 0xe0, 0x11, 0x74, 0x62, 0xc9, 0xb2, 0x91, 0x0a, 0x50, 0x09, 0xf5, 0x1e, 0xbc, 0xbf, 0x6e,
-	0x07, 0x67, 0xbd, 0x12, 0x5b, 0xb7, 0x32, 0x5b, 0x99, 0xcc, 0xa7, 0xb4, 0x52, 0x79, 0xfb, 0x73,
-	0xe8, 0x9f, 0x62, 0x29, 0x7f, 0x07, 0x7c, 0x6a, 0xab, 0x7a, 0xc0, 0xa7, 0x2a, 0xff, 0x43, 0x96,
-	0x96, 0x1c, 0x6b, 0xe5, 0x53, 0x4d, 0x7c, 0xe6, 0x7e, 0xe2, 0x90, 0x5d, 0x08, 0x36, 0x73, 0xce,
-	0x24, 0x47, 0x27, 0xdb, 0xbc, 0x28, 0xd8, 0x2b, 0x7e, 0x7e, 0xc5, 0x75, 0x15, 0xdd, 0x66, 0x15,
-	0xab, 0x3e, 0x78, 0x8d, 0x3e, 0x90, 0x7b, 0x10, 0x0c, 0x78, 0xca, 0x25, 0x37, 0x53, 0xff, 0x2f,
-	0x76, 0x49, 0x6c, 0x63, 0xb8, 0x58, 0x36, 0xb8, 0x0b, 0xbe, 0x5a, 0x21, 0x0c, 0xa1, 0xf7, 0xe0,
-	0x46, 0x5d, 0xa7, 0x6a, 0xbb, 0x28, 0x0a, 0x90, 0xd4, 0x1a, 0xc5, 0x78, 0x2e, 0x4c, 0x6c, 0xce,
-	0x28, 0xdd, 0x33, 0xae, 0x3c, 0x74, 0x75, 0xab, 0x76, 0xd5, 0x5c, 0x3f, 0xe3, 0xed, 0xb1, 0x4d,
-	0xf7, 0xaa, 0xde, 0xc8, 0x10, 0xde, 0xd1, 0x16, 0xbe, 0x3c, 0x64, 0x49, 0xca, 0xf6, 0xd2, 0x4b,
-	0x76, 0x64, 0x4e, 0xe0, 0x21, 0x2c, 0xa0, 0x6e, 0x34, 0x30, 0x5b, 0x60, 0x49, 0xf2, 0xd2, 0xc8,
-	0xab, 0xd1, 0x7f, 0xc6, 0xc6, 0xdc, 0x58, 0xc3, 0x77, 0x95, 0xaf, 0x7b, 0x71, 0xbe, 0xca, 0xb1,
-	0x5a, 0x17, 0x75, 0xc2, 0x3c, 0xe5, 0x18, 0x09, 0xf2, 0x10, 0xda, 0xf1, 0x70, 0x9f, 0x8f, 0x59,
-	0xf0, 0x21, 0x2c, 0x60, 0x84, 0xbc, 0x30, 0x13, 0x7d, 0x7d, 0xa6, 0x53, 0xd4, 0xf2, 0xc9, 0xc0,
-	0x64, 0x36, 0x37, 0xa6, 0xbb, 0xd0, 0x46, 0xef, 0x45, 0xe8, 0xcf, 0x9a, 0x41, 0x9c, 0x1a, 0x36,
-	0xd9, 0x02, 0xef, 0x05, 0x8d, 0xd4, 0xa6, 0x62, 0x04, 0xd6, 0x8a, 0xa1, 0x94, 0xed, 0xaf, 0x45,
-	0x21, 0x4d, 0x9d, 0xf0, 0xad, 0xb0, 0xe7, 0x22, 0x97, 0x58, 0xa3, 0x3e, 0xc5, 0x37, 0x79, 0x09,
-	0xfe, 0x33, 0x31, 0xe2, 0xc1, 0x22, 0xb8, 0xd1, 0xc0, 0xd8, 0x70, 0xa3, 0x41, 0xf0, 0x1e, 0x9a,
-	0x37, 0xa5, 0xe9, 0xd7, 0x41, 0xbc, 0xa0, 0x11, 0x45, 0xc7, 0x77, 0xa0, 0x1f, 0x15, 0x9b, 0x42,
-	0xe4, 0xa3, 0x24, 0x63, 0x52, 0xe4, 0xe6, 0xb6, 0x9f, 0x06, 0xc9, 0x63, 0x58, 0x52, 0xe6, 0x63,
-	0xc9, 0x24, 0xb7, 0x9d, 0xbd, 0x05, 0x6d, 0x85, 0x55, 0xee, 0x0c, 0x85, 0xdb, 0xa6, 0xe4, 0x6c,
-	0x6f, 0x91, 0x20, 0xdf, 0x6a, 0x0b, 0x5b, 0x87, 0x3c, 0x93, 0x8d, 0xd9, 0x40, 0x1a, 0x0d, 0xf4,
-	0xa9, 0x26, 0x02, 0xa2, 0x53, 0x31, 0x31, 0x2f, 0xd6, 0x31, 0x2b, 0x94, 0x22, 0x8f, 0xfc, 0xe2,
-	0x00, 0xd8, 0x80, 0xca, 0xa2, 0x52, 0x71, 0xce, 0x57, 0x09, 0xd6, 0x6c, 0x8f, 0xcd, 0x5e, 0x2c,
-	0xd5, 0x52, 0x1a, 0xa7, 0x76, 0x06, 0x3e, 0xae, 0x67, 0x40, 0x37, 0xef, 0xe6, 0xcc, 0x0c, 0x68,
-	0xaf, 0xf5, 0x24, 0x3c, 0x87, 0x5e, 0x03, 0x9f, 0x3b, 0x0f, 0x1f, 0x55, 0xf3, 0xe0, 0xce, 0x9a,
-	0x44, 0xdc, 0x98, 0xb4, 0x53, 0xf1, 0x14, 0x7a, 0x0d, 0x78, 0xae, 0xc5, 0x35, 0xb8, 0x7e, 0x7a,
-	0xe3, 0xec, 0x25, 0x9f, 0x85, 0x49, 0x02, 0xfd, 0xcd, 0xb4, 0x2c, 0x24, 0xcf, 0x8d, 0x39, 0x75,
-	0xfe, 0x35, 0x50, 0x35, 0xaf, 0x06, 0xe6, 0xf7, 0x2f, 0xb8, 0x03, 0x2d, 0x55, 0x46, 0xbd, 0x38,
-	0x67, 0x6b, 0xac, 0x99, 0x64, 0x17, 0x3a, 0x1b, 0x71, 0xf4, 0x24, 0x17, 0xe5, 0x64, 0x6e, 0xd0,
-	0xf6, 0xab, 0xec, 0x9e, 0xfd, 0x2a, 0x7b, 0x67, 0xbe, 0xca, 0x7e, 0xf5, 0x55, 0x26, 0x31, 0x2c,
-	0xeb, 0xa3, 0xa8, 0xf6, 0xf5, 0x2a, 0xa7, 0xc5, 0x7e, 0x32, 0xbd, 0xc6, 0x27, 0x33, 0x86, 0x65,
-	0x7d, 0xb9, 0xfe, 0x4f, 0xa3, 0xbf, 0xb9, 0xb0, 0x4c, 0x79, 0x91, 0xbc, 0xe6, 0x51, 0x56, 0xc8,
-	0xbc, 0x1c, 0xaa, 0xeb, 0xa3, 0xf4, 0xbf, 0x11, 0x7b, 0xa6, 0xda, 0x1e, 0xd5, 0xc4, 0x65, 0x26,
-	0x3d, 0xb8, 0x0f, 0xbd, 0xd9, 0xed, 0x3c, 0x2b, 0xda, 0x14, 0x09, 0xee, 0xc3, 0x42, 0x2c, 0xca,
-	0x7c, 0x58, 0x8d, 0x6f, 0xe3, 0x22, 0xea, 0xc8, 0x34, 0x9b, 0x5a, 0xb1, 0xc6, 0x6a, 0xb4, 0x2e,
-	0x58, 0x8d, 0x47, 0x33, 0xa3, 0x14, 0xb6, 0x51, 0xe1, 0xad, 0x5a, 0xe1, 0x14, 0x9b, 0x9e, 0x96,
-	0x26, 0x3f, 0x3b, 0x70, 0xad, 0x19, 0xc2, 0xa5, 0x16, 0xb7, 0xea, 0x88, 0x3b, 0xb7, 0x23, 0xde,
-	0xbc, 0x8e, 0xf8, 0x75, 0x47, 0xea, 0xaf, 0x7f, 0xab, 0xf1, 0xf5, 0x27, 0x07, 0x70, 0xfb, 0x4c,
-	0x9b, 0x36, 0xc5, 0x78, 0xa2, 0xe6, 0xe1, 0x3f, 0xb4, 0x4b, 0x9d, 0xb4, 0x3c, 0x37, 0x8d, 0xea,
-	0x52, 0x4d, 0x90, 0x4f, 0xe1, 0x66, 0xcc, 0x65, 0xa3, 0x49, 0x76, 0xda, 0x56, 0xc1, 0x7b, 0xc6,
-	0x8f, 0xce, 0x49, 0x5f, 0xb1, 0xc8, 0x17, 0x10, 0xbe, 0x98, 0x8c, 0x98, 0xe4, 0x57, 0xd2, 0xde,
-	0x80, 0xce, 0x8e, 0x98, 0x88, 0x54, 0xbc, 0x9a, 0x5e, 0xb0, 0xf5, 0x21, 0x2c, 0xe8, 0xfb, 0xad,
-	0xcf, 0x48, 0x97, 0x5a, 0x92, 0xdc, 0x50, 0x03, 0x3d, 0x64, 0xe9, 0xb0, 0x4c, 0x55, 0x18, 0xea,
-	0x97, 0x61, 0xb1, 0xb1, 0xf4, 0xc7, 0xc9, 0x8a, 0xf3, 0xe7, 0xc9, 0x8a, 0xf3, 0xd7, 0xc9, 0x8a,
-	0xf3, 0xeb, 0xdf, 0x2b, 0x6f, 0xec, 0xb5, 0xf1, 0x9f, 0xc3, 0xc3, 0x7f, 0x02, 0x00, 0x00, 0xff,
-	0xff, 0xba, 0x1b, 0x62, 0x68, 0x4a, 0x0c, 0x00, 0x00,
+var fileDescriptor_private_725d4d7695f6ae76 = []byte{
+	// 1121 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xdd, 0x6e, 0x1b, 0xc5,
+	0x17, 0xff, 0xef, 0x87, 0x1d, 0xfb, 0xb8, 0x4e, 0x93, 0xed, 0xbf, 0x61, 0x0b, 0x28, 0x84, 0x51,
+	0x45, 0x43, 0x25, 0x42, 0xd5, 0xde, 0xf0, 0x55, 0xa9, 0x24, 0x0e, 0x65, 0x29, 0x09, 0x65, 0x9c,
+	0xe4, 0x8e, 0x8b, 0x89, 0x3d, 0x6a, 0x56, 0x59, 0xef, 0x98, 0xdd, 0xd9, 0x24, 0xee, 0x05, 0xb7,
+	0x20, 0xf1, 0x02, 0x88, 0x27, 0xe1, 0x11, 0xb8, 0xe4, 0x11, 0x50, 0x78, 0x11, 0x34, 0x67, 0x66,
+	0x76, 0x37, 0x8e, 0x83, 0xa3, 0xc0, 0xdd, 0x9c, 0xdf, 0x99, 0xf9, 0x9d, 0xef, 0xb3, 0x36, 0x74,
+	0xc7, 0x59, 0x7c, 0xc2, 0x24, 0xdf, 0x18, 0x67, 0x42, 0x8a, 0xa0, 0x15, 0xa7, 0x92, 0x67, 0x29,
+	0x4b, 0xc8, 0x73, 0x68, 0x47, 0xe9, 0x90, 0x9f, 0xed, 0x70, 0xc9, 0x82, 0x00, 0xfc, 0x17, 0x7c,
+	0x92, 0x87, 0xde, 0x9a, 0xb3, 0xde, 0xa2, 0x78, 0x0e, 0xde, 0x83, 0xc5, 0xbd, 0x8c, 0x0d, 0x8e,
+	0xb7, 0xcf, 0xe2, 0x5c, 0xf2, 0x74, 0xc0, 0x43, 0x1f, 0xb5, 0x53, 0x28, 0xf9, 0xcd, 0x81, 0x5b,
+	0x5f, 0xc4, 0x3c, 0x19, 0x7e, 0x33, 0x96, 0xb1, 0x48, 0xf3, 0xe0, 0x6d, 0x68, 0x6f, 0xb1, 0xc1,
+	0x11, 0xdf, 0x9b, 0x8c, 0x39, 0x32, 0xb6, 0x69, 0x05, 0x94, 0xda, 0x7e, 0xfc, 0x5a, 0x33, 0x76,
+	0x69, 0x05, 0x04, 0x6b, 0xd0, 0xd9, 0x8b, 0x47, 0xfc, 0xdb, 0x82, 0xa5, 0xb2, 0x18, 0x85, 0x0d,
+	0x7c, 0x5d, 0x87, 0x94, 0xab, 0x48, 0xdc, 0x42, 0x15, 0x9e, 0x83, 0x25, 0xf0, 0x76, 0xe2, 0x34,
+	0x6c, 0xaf, 0x39, 0xeb, 0x1e, 0x55, 0x47, 0x44, 0xd8, 0x59, 0x08, 0x06, 0x61, 0x67, 0x65, 0x88,
+	0x9d, 0x2a, 0x44, 0x42, 0x60, 0x31, 0x1a, 0x8d, 0x45, 0x26, 0x29, 0xcf, 0xc7, 0x22, 0xcd, 0x91,
+	0x69, 0x3b, 0xcb, 0x42, 0x07, 0xc9, 0xd5, 0x91, 0xfc, 0x00, 0x4b, 0x9b, 0x89, 0x18, 0x1c, 0xf7,
+	0x98, 0x64, 0x94, 0x7f, 0x5f, 0xf0, 0x5c, 0x06, 0xff, 0x87, 0x06, 0xe6, 0xce, 0xdc, 0xd3, 0x82,
+	0x42, 0x31, 0x0f, 0xa1, 0xab, 0x51, 0x14, 0x14, 0x8a, 0xef, 0x31, 0x13, 0x3e, 0xd5, 0x82, 0x42,
+	0xfb, 0x47, 0x2c, 0x1b, 0x62, 0x06, 0x7c, 0xaa, 0x05, 0xe5, 0xe3, 0x41, 0xcc, 0x4f, 0x4d, 0xd8,
+	0x78, 0x26, 0x11, 0x2c, 0xd7, 0xec, 0x1b, 0x37, 0x57, 0xa0, 0x49, 0xc5, 0x69, 0xd4, 0xcb, 0x43,
+	0x67, 0xcd, 0x5b, 0xf7, 0xa9, 0x91, 0x30, 0xb9, 0x22, 0x29, 0x46, 0xa9, 0x52, 0xb9, 0xa8, 0xaa,
+	0x00, 0x72, 0x0f, 0x1a, 0x98, 0x69, 0x15, 0x65, 0xf5, 0x56, 0x1d, 0xc9, 0x8f, 0x0e, 0xb4, 0x77,
+	0xd8, 0x19, 0xba, 0x91, 0x07, 0x4f, 0xa1, 0xd5, 0x97, 0x2c, 0x1d, 0x2a, 0x07, 0xd5, 0xa5, 0xce,
+	0xe3, 0x77, 0x37, 0x6c, 0xe3, 0x6c, 0x94, 0xd7, 0x36, 0xec, 0x9d, 0xed, 0x54, 0x66, 0x13, 0x5a,
+	0x3e, 0x79, 0xf3, 0x53, 0xe8, 0x5e, 0x50, 0x29, 0x7b, 0xc7, 0x7c, 0x62, 0xb3, 0x7a, 0xcc, 0x27,
+	0x2a, 0xfe, 0x13, 0x96, 0x14, 0x1c, 0x73, 0xe5, 0x53, 0x2d, 0x7c, 0xe2, 0x7e, 0xe4, 0x90, 0x03,
+	0x08, 0xb6, 0x32, 0xce, 0x24, 0x47, 0x23, 0x3b, 0x3c, 0xcf, 0xd9, 0x2b, 0x7e, 0x75, 0xc6, 0x75,
+	0x16, 0xdd, 0x7a, 0x16, 0xcb, 0x3a, 0x78, 0xb5, 0x3a, 0x90, 0x87, 0x10, 0xf4, 0x78, 0xc2, 0x25,
+	0x37, 0x5d, 0xff, 0x0f, 0xbc, 0xa4, 0x6f, 0x7d, 0x98, 0x7f, 0x37, 0x78, 0x00, 0xbe, 0x1a, 0x21,
+	0x74, 0xa1, 0xf3, 0xf8, 0x4e, 0x95, 0xa7, 0x72, 0xba, 0x28, 0x5e, 0x20, 0x89, 0x25, 0x45, 0x7f,
+	0xe6, 0x06, 0x36, 0xa3, 0x95, 0x1e, 0x1a, 0x53, 0x1e, 0x9a, 0x5a, 0xa9, 0x4c, 0xd5, 0xc7, 0xcf,
+	0x58, 0x7b, 0x66, 0xc3, 0xbd, 0xa9, 0x35, 0x32, 0x80, 0xb7, 0x34, 0xc3, 0xe7, 0x27, 0x2c, 0x4e,
+	0xd8, 0x61, 0x72, 0xcd, 0x8a, 0xcc, 0x70, 0x3c, 0x84, 0x05, 0x7c, 0x1b, 0xf5, 0xcc, 0x14, 0x58,
+	0x91, 0x7c, 0x67, 0xee, 0xab, 0xd6, 0xdf, 0x65, 0x23, 0x6e, 0xd8, 0xf0, 0x5c, 0xc6, 0xeb, 0xce,
+	0x8f, 0x57, 0x19, 0x56, 0xe3, 0xa2, 0x56, 0x98, 0xa7, 0x0c, 0xa3, 0x40, 0x9e, 0x40, 0xb3, 0x3f,
+	0x38, 0xe2, 0x23, 0x16, 0xbc, 0x0f, 0x0b, 0xe8, 0x21, 0xcf, 0x4d, 0x47, 0xdf, 0x9e, 0xaa, 0x14,
+	0xb5, 0x7a, 0xd2, 0x33, 0x91, 0xcd, 0xf4, 0xe9, 0x01, 0x34, 0xd1, 0x7a, 0x1e, 0xfa, 0xd3, 0x34,
+	0x88, 0x53, 0xa3, 0x26, 0xdb, 0xe0, 0xed, 0xd3, 0x48, 0x4d, 0x2a, 0x7a, 0x60, 0x59, 0x8c, 0xa4,
+	0xb8, 0xbf, 0x14, 0xb9, 0x34, 0x79, 0xc2, 0xb3, 0xc2, 0x5e, 0x8a, 0x4c, 0x62, 0x8e, 0xba, 0x14,
+	0xcf, 0x24, 0x07, 0x7f, 0x57, 0x0c, 0x79, 0xb0, 0x08, 0x6e, 0xd4, 0x33, 0x1c, 0x6e, 0xd4, 0x0b,
+	0xde, 0x41, 0x7a, 0x93, 0x9a, 0x6e, 0xe5, 0xc4, 0x3e, 0x8d, 0x28, 0x1a, 0xbe, 0x0f, 0xdd, 0x28,
+	0xdf, 0x12, 0x22, 0x1b, 0xc6, 0x29, 0x93, 0x22, 0x33, 0xbb, 0xfd, 0x22, 0x88, 0x13, 0x24, 0x99,
+	0xd4, 0x9b, 0xb8, 0x4d, 0xb5, 0x40, 0x9e, 0xc1, 0x92, 0x32, 0x8a, 0x82, 0xad, 0xf7, 0x0a, 0x34,
+	0x15, 0x56, 0x3a, 0x61, 0xa4, 0x8a, 0xc1, 0xad, 0x33, 0x7c, 0xad, 0x19, 0xb6, 0x4f, 0x78, 0x2a,
+	0x6b, 0x1d, 0x83, 0x32, 0x12, 0x74, 0xa9, 0x16, 0x02, 0xa2, 0x03, 0x34, 0x91, 0x2c, 0x56, 0x91,
+	0x28, 0x94, 0xa2, 0x8e, 0xfc, 0xec, 0x00, 0x58, 0x87, 0x8a, 0xbc, 0x7c, 0xe2, 0x5c, 0xfd, 0x24,
+	0x58, 0xb7, 0x95, 0x37, 0xd3, 0xb2, 0x54, 0xdd, 0xd2, 0x38, 0xb5, 0x9d, 0xf1, 0x61, 0xd5, 0x19,
+	0xba, 0xa4, 0x77, 0xa7, 0x3a, 0x43, 0x5b, 0xad, 0xfa, 0xe3, 0x25, 0x74, 0x6a, 0xf8, 0xcc, 0x2e,
+	0xf9, 0xa0, 0xec, 0x12, 0x77, 0x9a, 0x12, 0x71, 0x43, 0x69, 0x7b, 0xe5, 0x05, 0x74, 0x6a, 0xf0,
+	0x4c, 0xc6, 0x75, 0xb8, 0x7d, 0x71, 0x0e, 0xed, 0x7e, 0x9f, 0x86, 0x49, 0x0c, 0xdd, 0xad, 0xa4,
+	0xc8, 0x25, 0xcf, 0x0c, 0x9d, 0xfa, 0x28, 0x68, 0xa0, 0x2c, 0x5e, 0x05, 0xcc, 0xae, 0x5f, 0x70,
+	0x1f, 0x1a, 0x2a, 0x8d, 0x7a, 0x9c, 0x2e, 0xe7, 0x58, 0x2b, 0xc9, 0x01, 0xb4, 0x36, 0xfb, 0xd1,
+	0xf3, 0x4c, 0x14, 0xe3, 0x99, 0x4e, 0xdb, 0x6f, 0xb5, 0x7b, 0xf9, 0x5b, 0xed, 0x5d, 0xfa, 0x56,
+	0xfb, 0xe5, 0xb7, 0x9a, 0xf4, 0x61, 0x59, 0xaf, 0x4a, 0x35, 0xc5, 0x37, 0x59, 0x38, 0xf6, 0x43,
+	0xea, 0xd5, 0x3e, 0xa4, 0x7d, 0x58, 0xd6, 0xfb, 0xec, 0xbf, 0x24, 0xfd, 0xd5, 0x85, 0x65, 0xca,
+	0xf3, 0xf8, 0x35, 0x8f, 0xd2, 0x5c, 0x66, 0xc5, 0x40, 0xed, 0x24, 0xf5, 0xfe, 0x2b, 0x71, 0x68,
+	0xb2, 0xed, 0x51, 0x2d, 0x5c, 0xa7, 0xd3, 0x83, 0x47, 0xd0, 0x99, 0x9e, 0xd9, 0xcb, 0x57, 0xeb,
+	0x57, 0x82, 0x47, 0xb0, 0xd0, 0x17, 0x45, 0x36, 0x28, 0xdb, 0xb7, 0xb6, 0x27, 0xb5, 0x67, 0x5a,
+	0x4d, 0xed, 0xb5, 0xda, 0x68, 0x34, 0xe6, 0x8c, 0xc6, 0xd3, 0xa9, 0x56, 0x0a, 0x9b, 0xf8, 0xe0,
+	0x8d, 0xea, 0xc1, 0x05, 0x35, 0xbd, 0x78, 0x9b, 0xfc, 0xe4, 0xc0, 0xad, 0xba, 0x0b, 0xd7, 0x1a,
+	0xdc, 0xb2, 0x22, 0xee, 0xcc, 0x8a, 0x78, 0xb3, 0x2a, 0xe2, 0x57, 0x15, 0xa9, 0x7e, 0x13, 0x34,
+	0x6a, 0xbf, 0x09, 0xc8, 0x31, 0xdc, 0xbb, 0x54, 0xa6, 0x2d, 0x31, 0x1a, 0xab, 0x7e, 0xf8, 0x17,
+	0xe5, 0x52, 0x2b, 0x2d, 0xcb, 0x4c, 0xa1, 0xda, 0x54, 0x0b, 0xe4, 0x63, 0xb8, 0xdb, 0xe7, 0xb2,
+	0x56, 0x24, 0xdb, 0x6d, 0x6b, 0xe0, 0xed, 0xf2, 0xd3, 0x2b, 0xc2, 0x57, 0x2a, 0xf2, 0x19, 0x84,
+	0xfb, 0xe3, 0x21, 0x93, 0xfc, 0x46, 0xaf, 0x37, 0xa1, 0xb5, 0x27, 0xc6, 0x22, 0x11, 0xaf, 0x26,
+	0x73, 0xa6, 0x3e, 0x84, 0x05, 0xbd, 0xbf, 0xf5, 0x1a, 0x69, 0x53, 0x2b, 0x92, 0x3b, 0xaa, 0xa1,
+	0x07, 0x2c, 0x19, 0x14, 0x89, 0x72, 0x43, 0xfd, 0x5e, 0xcc, 0x37, 0x97, 0x7e, 0x3f, 0x5f, 0x75,
+	0xfe, 0x38, 0x5f, 0x75, 0xfe, 0x3c, 0x5f, 0x75, 0x7e, 0xf9, 0x6b, 0xf5, 0x7f, 0x87, 0x4d, 0xfc,
+	0x3f, 0xf1, 0xe4, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x46, 0x93, 0xc0, 0xc1, 0x60, 0x0c, 0x00,
+	0x00,
 }
--- a/internal/private.proto
+++ b/internal/private.proto
@ -99,6 +99,7 @@ message Node {
    string ID = 1;
    URI URI = 2;
    bool IsCoordinator = 3;
+    string State = 4;
 }

 message NodeStateMessage {
--- a/logger/logger.go
+++ b/logger/logger.go
@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-package pilosa
+package logger

 import (
 	"io"
@ -39,7 +39,7 @@ func (n *nopLogger) Printf(format string, v ...interface{}) {}
 // Debugf is a no-op implementation of the Logger Debugf method.
 func (n *nopLogger) Debugf(format string, v ...interface{}) {}

-// standardLogger is a basic implementation of pilosa.Logger based on log.Logger.
+// standardLogger is a basic implementation of Logger based on log.Logger.
 type standardLogger struct {
 	logger *log.Logger
 }
@ -60,7 +60,7 @@ func (s *standardLogger) Logger() *log.Logger {
 	return s.logger
 }

-// verboseLogger is an implementation of pilosa.Logger which includes debug messages.
+// verboseLogger is an implementation of Logger which includes debug messages.
 type verboseLogger struct {
 	logger *log.Logger
 }
--- a/pql/pql.peg
+++ b/pql/pql.peg
@ -57,7 +57,6 @@ field <- <fieldExpr / reserved> { p.addField(buffer[begin:end]) }
 reserved <- ('_row' / '_col' / '_start' / '_end' / '_timestamp' / '_field')
 posfield <- <fieldExpr> { p.addPosStr("_field", buffer[begin:end]) }
 uint <- [1-9] [0-9]* / '0'
-uintrow <- <uint>{p.addPosNum("_row", buffer[begin:end])}
 col <- ( <uint> {p.addPosNum("_col", buffer[begin:end])}
        / '\'' <singlequotedstring> '\'' {p.addPosStr("_col", buffer[begin:end])}
        / '"' <doublequotedstring> '"' {p.addPosStr("_col", buffer[begin:end])}
--- a/pql/pql.peg.go
+++ b/pql/pql.peg.go
@ -37,7 +37,6 @@ const (
 	rulereserved
 	ruleposfield
 	ruleuint
-	ruleuintrow
 	rulecol
 	rulerow
 	ruleopen
@ -102,7 +101,6 @@ const (
 	ruleAction48
 	ruleAction49
 	ruleAction50
-	ruleAction51
 )

 var rul3s = [...]string{
@ -128,7 +126,6 @@ var rul3s = [...]string{
 	"reserved",
 	"posfield",
 	"uint",
-	"uintrow",
 	"col",
 	"row",
 	"open",
@ -193,7 +190,6 @@ var rul3s = [...]string{
 	"Action48",
 	"Action49",
 	"Action50",
-	"Action51",
 }

 type token32 struct {
@ -310,7 +306,7 @@ type PQL struct {

 	Buffer string
 	buffer []rune
-	rules  [88]func() bool
+	rules  [86]func() bool
 	parse  func(rule ...int) error
 	reset  func()
 	Pretty bool
@ -492,20 +488,18 @@ func (p *PQL) Execute() {
 		case ruleAction43:
 			p.addPosStr("_field", buffer[begin:end])
 		case ruleAction44:
-			p.addPosNum("_row", buffer[begin:end])
-		case ruleAction45:
 			p.addPosNum("_col", buffer[begin:end])
+		case ruleAction45:
+			p.addPosStr("_col", buffer[begin:end])
 		case ruleAction46:
 			p.addPosStr("_col", buffer[begin:end])
 		case ruleAction47:
-			p.addPosStr("_col", buffer[begin:end])
-		case ruleAction48:
 			p.addPosNum("_row", buffer[begin:end])
+		case ruleAction48:
+			p.addPosStr("_row", buffer[begin:end])
 		case ruleAction49:
 			p.addPosStr("_row", buffer[begin:end])
 		case ruleAction50:
-			p.addPosStr("_row", buffer[begin:end])
-		case ruleAction51:
 			p.addPosStr("_timestamp", buffer[begin:end])

 		}
@ -667,7 +661,7 @@ func (p *PQL) Init() {
 								add(rulePegText, position13)
 							}
 							{
-								add(ruleAction51, position)
+								add(ruleAction50, position)
 							}
 							add(ruletimestamp, position12)
 						}
@ -753,7 +747,7 @@ func (p *PQL) Init() {
 								add(rulePegText, position21)
 							}
 							{
-								add(ruleAction48, position)
+								add(ruleAction47, position)
 							}
 							goto l19
 						l20:
@ -774,7 +768,7 @@ func (p *PQL) Init() {
 							}
 							position++
 							{
-								add(ruleAction49, position)
+								add(ruleAction48, position)
 							}
 							goto l19
 						l23:
@ -795,7 +789,7 @@ func (p *PQL) Init() {
 							}
 							position++
 							{
-								add(ruleAction50, position)
+								add(ruleAction49, position)
 							}
 						}
 					l19:
@ -2536,421 +2530,417 @@ func (p *PQL) Init() {
 			position, tokenIndex = position243, tokenIndex243
 			return false
 		},
-		/* 21 uintrow <- <(<uint> Action44)> */
-		nil,
-		/* 22 col <- <((<uint> Action45) / ('\'' <singlequotedstring> '\'' Action46) / ('"' <doublequotedstring> '"' Action47))> */
+		/* 21 col <- <((<uint> Action44) / ('\'' <singlequotedstring> '\'' Action45) / ('"' <doublequotedstring> '"' Action46))> */
 		func() bool {
-			position250, tokenIndex250 := position, tokenIndex
+			position249, tokenIndex249 := position, tokenIndex
 			{
-				position251 := position
+				position250 := position
 				{
-					position252, tokenIndex252 := position, tokenIndex
+					position251, tokenIndex251 := position, tokenIndex
 					{
-						position254 := position
+						position253 := position
 						if !_rules[ruleuint]() {
-							goto l253
+							goto l252
 						}
-						add(rulePegText, position254)
+						add(rulePegText, position253)
 					}
 					{
-						add(ruleAction45, position)
+						add(ruleAction44, position)
 					}
-					goto l252
-				l253:
-					position, tokenIndex = position252, tokenIndex252
+					goto l251
+				l252:
+					position, tokenIndex = position251, tokenIndex251
 					if buffer[position] != rune('\'') {
-						goto l256
+						goto l255
 					}
 					position++
 					{
-						position257 := position
+						position256 := position
 						if !_rules[rulesinglequotedstring]() {
-							goto l256
+							goto l255
 						}
-						add(rulePegText, position257)
+						add(rulePegText, position256)
 					}
 					if buffer[position] != rune('\'') {
-						goto l256
+						goto l255
+					}
+					position++
+					{
+						add(ruleAction45, position)
+					}
+					goto l251
+				l255:
+					position, tokenIndex = position251, tokenIndex251
+					if buffer[position] != rune('"') {
+						goto l249
+					}
+					position++
+					{
+						position258 := position
+						if !_rules[ruledoublequotedstring]() {
+							goto l249
+						}
+						add(rulePegText, position258)
+					}
+					if buffer[position] != rune('"') {
+						goto l249
 					}
 					position++
 					{
 						add(ruleAction46, position)
 					}
-					goto l252
-				l256:
-					position, tokenIndex = position252, tokenIndex252
-					if buffer[position] != rune('"') {
-						goto l250
-					}
-					position++
-					{
-						position259 := position
-						if !_rules[ruledoublequotedstring]() {
-							goto l250
-						}
-						add(rulePegText, position259)
-					}
-					if buffer[position] != rune('"') {
-						goto l250
-					}
-					position++
-					{
-						add(ruleAction47, position)
-					}
 				}
-			l252:
-				add(rulecol, position251)
+			l251:
+				add(rulecol, position250)
 			}
 			return true
-		l250:
-			position, tokenIndex = position250, tokenIndex250
+		l249:
+			position, tokenIndex = position249, tokenIndex249
 			return false
 		},
-		/* 23 row <- <((<uint> Action48) / ('\'' <singlequotedstring> '\'' Action49) / ('"' <doublequotedstring> '"' Action50))> */
+		/* 22 row <- <((<uint> Action47) / ('\'' <singlequotedstring> '\'' Action48) / ('"' <doublequotedstring> '"' Action49))> */
 		nil,
-		/* 24 open <- <('(' sp)> */
+		/* 23 open <- <('(' sp)> */
 		func() bool {
-			position262, tokenIndex262 := position, tokenIndex
+			position261, tokenIndex261 := position, tokenIndex
 			{
-				position263 := position
+				position262 := position
 				if buffer[position] != rune('(') {
-					goto l262
+					goto l261
 				}
 				position++
 				if !_rules[rulesp]() {
-					goto l262
+					goto l261
 				}
-				add(ruleopen, position263)
+				add(ruleopen, position262)
 			}
 			return true
-		l262:
-			position, tokenIndex = position262, tokenIndex262
+		l261:
+			position, tokenIndex = position261, tokenIndex261
 			return false
 		},
-		/* 25 close <- <(')' sp)> */
+		/* 24 close <- <(')' sp)> */
 		func() bool {
-			position264, tokenIndex264 := position, tokenIndex
+			position263, tokenIndex263 := position, tokenIndex
 			{
-				position265 := position
+				position264 := position
 				if buffer[position] != rune(')') {
-					goto l264
+					goto l263
 				}
 				position++
 				if !_rules[rulesp]() {
-					goto l264
+					goto l263
 				}
-				add(ruleclose, position265)
+				add(ruleclose, position264)
 			}
 			return true
-		l264:
-			position, tokenIndex = position264, tokenIndex264
+		l263:
+			position, tokenIndex = position263, tokenIndex263
 			return false
 		},
-		/* 26 sp <- <(' ' / '\t' / '\n')*> */
+		/* 25 sp <- <(' ' / '\t' / '\n')*> */
 		func() bool {
 			{
-				position267 := position
-			l268:
+				position266 := position
+			l267:
 				{
-					position269, tokenIndex269 := position, tokenIndex
+					position268, tokenIndex268 := position, tokenIndex
 					{
-						position270, tokenIndex270 := position, tokenIndex
+						position269, tokenIndex269 := position, tokenIndex
 						if buffer[position] != rune(' ') {
+							goto l270
+						}
+						position++
+						goto l269
+					l270:
+						position, tokenIndex = position269, tokenIndex269
+						if buffer[position] != rune('\t') {
 							goto l271
 						}
 						position++
-						goto l270
+						goto l269
 					l271:
-						position, tokenIndex = position270, tokenIndex270
-						if buffer[position] != rune('\t') {
-							goto l272
-						}
-						position++
-						goto l270
-					l272:
-						position, tokenIndex = position270, tokenIndex270
+						position, tokenIndex = position269, tokenIndex269
 						if buffer[position] != rune('\n') {
-							goto l269
+							goto l268
 						}
 						position++
 					}
-				l270:
-					goto l268
 				l269:
-					position, tokenIndex = position269, tokenIndex269
+					goto l267
+				l268:
+					position, tokenIndex = position268, tokenIndex268
 				}
-				add(rulesp, position267)
+				add(rulesp, position266)
 			}
 			return true
 		},
-		/* 27 comma <- <(sp ',' sp)> */
+		/* 26 comma <- <(sp ',' sp)> */
 		func() bool {
-			position273, tokenIndex273 := position, tokenIndex
+			position272, tokenIndex272 := position, tokenIndex
 			{
-				position274 := position
+				position273 := position
 				if !_rules[rulesp]() {
-					goto l273
+					goto l272
 				}
 				if buffer[position] != rune(',') {
-					goto l273
+					goto l272
 				}
 				position++
 				if !_rules[rulesp]() {
-					goto l273
+					goto l272
 				}
-				add(rulecomma, position274)
+				add(rulecomma, position273)
 			}
 			return true
-		l273:
-			position, tokenIndex = position273, tokenIndex273
+		l272:
+			position, tokenIndex = position272, tokenIndex272
 			return false
 		},
-		/* 28 lbrack <- <('[' sp)> */
+		/* 27 lbrack <- <('[' sp)> */
 		nil,
-		/* 29 rbrack <- <(sp ']' sp)> */
+		/* 28 rbrack <- <(sp ']' sp)> */
 		nil,
-		/* 30 IDENT <- <(([a-z] / [A-Z]) ([a-z] / [A-Z] / [0-9])*)> */
+		/* 29 IDENT <- <(([a-z] / [A-Z]) ([a-z] / [A-Z] / [0-9])*)> */
 		nil,
-		/* 31 timestampbasicfmt <- <([0-9] [0-9] [0-9] [0-9] '-' ('0' / '1') [0-9] '-' [0-3] [0-9] 'T' [0-9] [0-9] ':' [0-9] [0-9])> */
+		/* 30 timestampbasicfmt <- <([0-9] [0-9] [0-9] [0-9] '-' ('0' / '1') [0-9] '-' [0-3] [0-9] 'T' [0-9] [0-9] ':' [0-9] [0-9])> */
 		func() bool {
-			position278, tokenIndex278 := position, tokenIndex
+			position277, tokenIndex277 := position, tokenIndex
 			{
-				position279 := position
+				position278 := position
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l278
+					goto l277
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l278
+					goto l277
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l278
+					goto l277
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l278
+					goto l277
 				}
 				position++
 				if buffer[position] != rune('-') {
-					goto l278
+					goto l277
 				}
 				position++
 				{
-					position280, tokenIndex280 := position, tokenIndex
+					position279, tokenIndex279 := position, tokenIndex
 					if buffer[position] != rune('0') {
-						goto l281
+						goto l280
 					}
 					position++
-					goto l280
-				l281:
-					position, tokenIndex = position280, tokenIndex280
+					goto l279
+				l280:
+					position, tokenIndex = position279, tokenIndex279
 					if buffer[position] != rune('1') {
-						goto l278
+						goto l277
 					}
 					position++
 				}
-			l280:
+			l279:
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l278
+					goto l277
 				}
 				position++
 				if buffer[position] != rune('-') {
-					goto l278
+					goto l277
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('3') {
-					goto l278
+					goto l277
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l278
+					goto l277
 				}
 				position++
 				if buffer[position] != rune('T') {
-					goto l278
+					goto l277
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l278
+					goto l277
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l278
+					goto l277
 				}
 				position++
 				if buffer[position] != rune(':') {
-					goto l278
+					goto l277
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l278
+					goto l277
 				}
 				position++
 				if c := buffer[position]; c < rune('0') || c > rune('9') {
-					goto l278
+					goto l277
 				}
 				position++
-				add(ruletimestampbasicfmt, position279)
+				add(ruletimestampbasicfmt, position278)
 			}
 			return true
-		l278:
-			position, tokenIndex = position278, tokenIndex278
+		l277:
+			position, tokenIndex = position277, tokenIndex277
 			return false
 		},
-		/* 32 timestampfmt <- <(('"' timestampbasicfmt '"') / ('\'' timestampbasicfmt '\'') / timestampbasicfmt)> */
+		/* 31 timestampfmt <- <(('"' timestampbasicfmt '"') / ('\'' timestampbasicfmt '\'') / timestampbasicfmt)> */
 		func() bool {
-			position282, tokenIndex282 := position, tokenIndex
+			position281, tokenIndex281 := position, tokenIndex
 			{
-				position283 := position
+				position282 := position
 				{
-					position284, tokenIndex284 := position, tokenIndex
+					position283, tokenIndex283 := position, tokenIndex
 					if buffer[position] != rune('"') {
+						goto l284
+					}
+					position++
+					if !_rules[ruletimestampbasicfmt]() {
+						goto l284
+					}
+					if buffer[position] != rune('"') {
+						goto l284
+					}
+					position++
+					goto l283
+				l284:
+					position, tokenIndex = position283, tokenIndex283
+					if buffer[position] != rune('\'') {
 						goto l285
 					}
 					position++
 					if !_rules[ruletimestampbasicfmt]() {
 						goto l285
 					}
-					if buffer[position] != rune('"') {
+					if buffer[position] != rune('\'') {
 						goto l285
 					}
 					position++
-					goto l284
+					goto l283
 				l285:
-					position, tokenIndex = position284, tokenIndex284
-					if buffer[position] != rune('\'') {
-						goto l286
-					}
-					position++
+					position, tokenIndex = position283, tokenIndex283
 					if !_rules[ruletimestampbasicfmt]() {
-						goto l286
-					}
-					if buffer[position] != rune('\'') {
-						goto l286
-					}
-					position++
-					goto l284
-				l286:
-					position, tokenIndex = position284, tokenIndex284
-					if !_rules[ruletimestampbasicfmt]() {
-						goto l282
+						goto l281
 					}
 				}
-			l284:
-				add(ruletimestampfmt, position283)
+			l283:
+				add(ruletimestampfmt, position282)
 			}
 			return true
-		l282:
-			position, tokenIndex = position282, tokenIndex282
+		l281:
+			position, tokenIndex = position281, tokenIndex281
 			return false
 		},
-		/* 33 timestamp <- <(<timestampfmt> Action51)> */
+		/* 32 timestamp <- <(<timestampfmt> Action50)> */
 		nil,
-		/* 35 Action0 <- <{p.startCall("Set")}> */
+		/* 34 Action0 <- <{p.startCall("Set")}> */
 		nil,
-		/* 36 Action1 <- <{p.endCall()}> */
+		/* 35 Action1 <- <{p.endCall()}> */
 		nil,
-		/* 37 Action2 <- <{p.startCall("SetRowAttrs")}> */
+		/* 36 Action2 <- <{p.startCall("SetRowAttrs")}> */
 		nil,
-		/* 38 Action3 <- <{p.endCall()}> */
+		/* 37 Action3 <- <{p.endCall()}> */
 		nil,
-		/* 39 Action4 <- <{p.startCall("SetColumnAttrs")}> */
+		/* 38 Action4 <- <{p.startCall("SetColumnAttrs")}> */
 		nil,
-		/* 40 Action5 <- <{p.endCall()}> */
+		/* 39 Action5 <- <{p.endCall()}> */
 		nil,
-		/* 41 Action6 <- <{p.startCall("Clear")}> */
+		/* 40 Action6 <- <{p.startCall("Clear")}> */
 		nil,
-		/* 42 Action7 <- <{p.endCall()}> */
+		/* 41 Action7 <- <{p.endCall()}> */
 		nil,
-		/* 43 Action8 <- <{p.startCall("ClearRow")}> */
+		/* 42 Action8 <- <{p.startCall("ClearRow")}> */
 		nil,
-		/* 44 Action9 <- <{p.endCall()}> */
+		/* 43 Action9 <- <{p.endCall()}> */
 		nil,
-		/* 45 Action10 <- <{p.startCall("Store")}> */
+		/* 44 Action10 <- <{p.startCall("Store")}> */
 		nil,
-		/* 46 Action11 <- <{p.endCall()}> */
+		/* 45 Action11 <- <{p.endCall()}> */
 		nil,
-		/* 47 Action12 <- <{p.startCall("TopN")}> */
+		/* 46 Action12 <- <{p.startCall("TopN")}> */
 		nil,
-		/* 48 Action13 <- <{p.endCall()}> */
+		/* 47 Action13 <- <{p.endCall()}> */
 		nil,
-		/* 49 Action14 <- <{p.startCall("Range")}> */
+		/* 48 Action14 <- <{p.startCall("Range")}> */
 		nil,
-		/* 50 Action15 <- <{p.endCall()}> */
+		/* 49 Action15 <- <{p.endCall()}> */
 		nil,
 		nil,
-		/* 52 Action16 <- <{ p.startCall(buffer[begin:end] ) }> */
+		/* 51 Action16 <- <{ p.startCall(buffer[begin:end] ) }> */
 		nil,
-		/* 53 Action17 <- <{ p.endCall() }> */
+		/* 52 Action17 <- <{ p.endCall() }> */
 		nil,
-		/* 54 Action18 <- <{ p.addBTWN() }> */
+		/* 53 Action18 <- <{ p.addBTWN() }> */
 		nil,
-		/* 55 Action19 <- <{ p.addLTE() }> */
+		/* 54 Action19 <- <{ p.addLTE() }> */
 		nil,
-		/* 56 Action20 <- <{ p.addGTE() }> */
+		/* 55 Action20 <- <{ p.addGTE() }> */
 		nil,
-		/* 57 Action21 <- <{ p.addEQ() }> */
+		/* 56 Action21 <- <{ p.addEQ() }> */
 		nil,
-		/* 58 Action22 <- <{ p.addNEQ() }> */
+		/* 57 Action22 <- <{ p.addNEQ() }> */
 		nil,
-		/* 59 Action23 <- <{ p.addLT() }> */
+		/* 58 Action23 <- <{ p.addLT() }> */
 		nil,
-		/* 60 Action24 <- <{ p.addGT() }> */
+		/* 59 Action24 <- <{ p.addGT() }> */
 		nil,
-		/* 61 Action25 <- <{p.startConditional()}> */
+		/* 60 Action25 <- <{p.startConditional()}> */
 		nil,
-		/* 62 Action26 <- <{p.endConditional()}> */
+		/* 61 Action26 <- <{p.endConditional()}> */
 		nil,
-		/* 63 Action27 <- <{p.condAdd(buffer[begin:end])}> */
+		/* 62 Action27 <- <{p.condAdd(buffer[begin:end])}> */
 		nil,
-		/* 64 Action28 <- <{p.condAdd(buffer[begin:end])}> */
+		/* 63 Action28 <- <{p.condAdd(buffer[begin:end])}> */
 		nil,
-		/* 65 Action29 <- <{p.condAdd(buffer[begin:end])}> */
+		/* 64 Action29 <- <{p.condAdd(buffer[begin:end])}> */
 		nil,
-		/* 66 Action30 <- <{p.addPosStr("_start", buffer[begin:end])}> */
+		/* 65 Action30 <- <{p.addPosStr("_start", buffer[begin:end])}> */
 		nil,
-		/* 67 Action31 <- <{p.addPosStr("_end", buffer[begin:end])}> */
+		/* 66 Action31 <- <{p.addPosStr("_end", buffer[begin:end])}> */
 		nil,
-		/* 68 Action32 <- <{ p.startList() }> */
+		/* 67 Action32 <- <{ p.startList() }> */
 		nil,
-		/* 69 Action33 <- <{ p.endList() }> */
+		/* 68 Action33 <- <{ p.endList() }> */
 		nil,
-		/* 70 Action34 <- <{ p.addVal(nil) }> */
+		/* 69 Action34 <- <{ p.addVal(nil) }> */
 		nil,
-		/* 71 Action35 <- <{ p.addVal(true) }> */
+		/* 70 Action35 <- <{ p.addVal(true) }> */
 		nil,
-		/* 72 Action36 <- <{ p.addVal(false) }> */
+		/* 71 Action36 <- <{ p.addVal(false) }> */
 		nil,
-		/* 73 Action37 <- <{ p.addNumVal(buffer[begin:end]) }> */
+		/* 72 Action37 <- <{ p.addNumVal(buffer[begin:end]) }> */
 		nil,
-		/* 74 Action38 <- <{ p.addNumVal(buffer[begin:end]) }> */
+		/* 73 Action38 <- <{ p.addNumVal(buffer[begin:end]) }> */
 		nil,
-		/* 75 Action39 <- <{ p.addVal(buffer[begin:end]) }> */
+		/* 74 Action39 <- <{ p.addVal(buffer[begin:end]) }> */
 		nil,
-		/* 76 Action40 <- <{ s, _ := strconv.Unquote(buffer[begin:end]); p.addVal(s) }> */
+		/* 75 Action40 <- <{ s, _ := strconv.Unquote(buffer[begin:end]); p.addVal(s) }> */
 		nil,
-		/* 77 Action41 <- <{ p.addVal(buffer[begin:end]) }> */
+		/* 76 Action41 <- <{ p.addVal(buffer[begin:end]) }> */
 		nil,
-		/* 78 Action42 <- <{ p.addField(buffer[begin:end]) }> */
+		/* 77 Action42 <- <{ p.addField(buffer[begin:end]) }> */
 		nil,
-		/* 79 Action43 <- <{ p.addPosStr("_field", buffer[begin:end]) }> */
+		/* 78 Action43 <- <{ p.addPosStr("_field", buffer[begin:end]) }> */
 		nil,
-		/* 80 Action44 <- <{p.addPosNum("_row", buffer[begin:end])}> */
+		/* 79 Action44 <- <{p.addPosNum("_col", buffer[begin:end])}> */
 		nil,
-		/* 81 Action45 <- <{p.addPosNum("_col", buffer[begin:end])}> */
+		/* 80 Action45 <- <{p.addPosStr("_col", buffer[begin:end])}> */
 		nil,
-		/* 82 Action46 <- <{p.addPosStr("_col", buffer[begin:end])}> */
+		/* 81 Action46 <- <{p.addPosStr("_col", buffer[begin:end])}> */
 		nil,
-		/* 83 Action47 <- <{p.addPosStr("_col", buffer[begin:end])}> */
+		/* 82 Action47 <- <{p.addPosNum("_row", buffer[begin:end])}> */
 		nil,
-		/* 84 Action48 <- <{p.addPosNum("_row", buffer[begin:end])}> */
+		/* 83 Action48 <- <{p.addPosStr("_row", buffer[begin:end])}> */
 		nil,
-		/* 85 Action49 <- <{p.addPosStr("_row", buffer[begin:end])}> */
+		/* 84 Action49 <- <{p.addPosStr("_row", buffer[begin:end])}> */
 		nil,
-		/* 86 Action50 <- <{p.addPosStr("_row", buffer[begin:end])}> */
-		nil,
-		/* 87 Action51 <- <{p.addPosStr("_timestamp", buffer[begin:end])}> */
+		/* 85 Action50 <- <{p.addPosStr("_timestamp", buffer[begin:end])}> */
 		nil,
 	}
 	p.rules = _rules
--- a/roaring/containers.go
+++ b/roaring/containers.go
@ -64,6 +64,7 @@ func (sc *sliceContainers) PutContainerValues(key uint64, containerType byte, n
 }

 func (sc *sliceContainers) Remove(key uint64) {
+	statsHit("sliceContainers/Remove")
 	i := search64(sc.keys, key)
 	if i < 0 {
 		return
@ -73,6 +74,7 @@ func (sc *sliceContainers) Remove(key uint64) {

 }
 func (sc *sliceContainers) insertAt(key uint64, c *Container, i int) {
+	statsHit("sliceContainers/insertAt")
 	sc.keys = append(sc.keys, 0)
 	copy(sc.keys[i+1:], sc.keys[i:])
 	sc.keys[i] = key
--- a/roaring/roaring.go
+++ b/roaring/roaring.go
@ -1027,6 +1027,7 @@ func (iv interval16) runlen() int32 {

 // newContainer returns a new instance of container.
 func NewContainer() *Container {
+	statsHit("NewContainer")
 	return &Container{containerType: containerArray}
 }

@ -1194,6 +1195,7 @@ func (c *Container) add(v uint16) (added bool) {
 func (c *Container) arrayAdd(v uint16) bool {
 	// Optimize appending to the end of an array container.
 	if c.n > 0 && c.n < ArrayMaxSize && c.isArray() && c.array[c.n-1] < v {
+		statsHit("arrayAdd/append")
 		c.unmap()
 		c.array = append(c.array, v)
 		return true
@ -1207,11 +1209,13 @@ func (c *Container) arrayAdd(v uint16) bool {

 	// Convert to a bitmap container if too many values are in an array container.
 	if c.n >= ArrayMaxSize {
+		statsHit("arrayAdd/arrayToBitmap")
 		c.arrayToBitmap()
 		return c.bitmapAdd(v)
 	}

 	// Otherwise insert into array.
+	statsHit("arrayAdd/insert")
 	c.unmap()
 	i = -i - 1
 	c.array = append(c.array, 0)
@ -1325,6 +1329,7 @@ func (c *Container) countRuns() (r int32) {
 // amount of space.
 func (c *Container) optimize() {
 	if c.n == 0 {
+		statsHit("optimize/empty")
 		return
 	}
 	runs := c.countRuns()
@ -1341,21 +1346,33 @@ func (c *Container) optimize() {
 	// Then convert accordingly.
 	if c.isArray() {
 		if newType == containerBitmap {
+			statsHit("optimize/arrayToBitmap")
 			c.arrayToBitmap()
 		} else if newType == containerRun {
+			statsHit("optimize/arrayToRun")
 			c.arrayToRun()
+		} else {
+			statsHit("optimize/arrayUnchanged")
 		}
 	} else if c.isBitmap() {
 		if newType == containerArray {
+			statsHit("optimize/bitmapToArray")
 			c.bitmapToArray()
 		} else if newType == containerRun {
+			statsHit("optimize/bitmapToRun")
 			c.bitmapToRun()
+		} else {
+			statsHit("optimize/bitmapUnchanged")
 		}
 	} else if c.isRun() {
 		if newType == containerBitmap {
+			statsHit("optimize/runToBitmap")
 			c.runToBitmap()
 		} else if newType == containerArray {
+			statsHit("optimize/runToArray")
 			c.runToArray()
+		} else {
+			statsHit("optimize/runUnchanged")
 		}
 	}
 }
@ -1425,6 +1442,7 @@ func (c *Container) bitmapRemove(v uint16) bool {

 	// Convert to array if we go below the threshold.
 	if c.n == ArrayMaxSize {
+		statsHit("bitmapRemove/bitmapToArray")
 		c.bitmapToArray()
 	}
 	return true
@ -1492,6 +1510,7 @@ func (c *Container) runMax() uint16 {

 // bitmapToArray converts from bitmap format to array format.
 func (c *Container) bitmapToArray() {
+	statsHit("bitmapToArray")
 	c.array = make([]uint16, 0, c.n)
 	c.containerType = containerArray

@ -1515,6 +1534,7 @@ func (c *Container) bitmapToArray() {

 // arrayToBitmap converts from array format to bitmap format.
 func (c *Container) arrayToBitmap() {
+	statsHit("arrayToBitmap")
 	c.bitmap = make([]uint64, bitmapN)
 	c.containerType = containerBitmap

@ -1534,6 +1554,7 @@ func (c *Container) arrayToBitmap() {

 // runToBitmap converts from RLE format to bitmap format.
 func (c *Container) runToBitmap() {
+	statsHit("runToBitmap")
 	c.bitmap = make([]uint64, bitmapN)
 	c.containerType = containerBitmap

@ -1557,6 +1578,7 @@ func (c *Container) runToBitmap() {

 // bitmapToRun converts from bitmap format to RLE format.
 func (c *Container) bitmapToRun() {
+	statsHit("bitmapToRun")
 	c.containerType = containerRun
 	// return early if empty
 	if c.n == 0 {
@ -1613,6 +1635,7 @@ func (c *Container) bitmapToRun() {

 // arrayToRun converts from array format to RLE format.
 func (c *Container) arrayToRun() {
+	statsHit("arrayToRun")
 	c.containerType = containerRun
 	// return early if empty
 	if c.n == 0 {
@ -1640,6 +1663,7 @@ func (c *Container) arrayToRun() {

 // runToArray converts from RLE format to array format.
 func (c *Container) runToArray() {
+	statsHit("runToArray")
 	c.containerType = containerArray
 	c.array = make([]uint16, 0, c.n)

@ -1661,16 +1685,20 @@ func (c *Container) runToArray() {

 // Clone returns a copy of c.
 func (c *Container) Clone() *Container {
+	statsHit("Container/Clone")
 	other := &Container{n: c.n, containerType: c.containerType}

 	switch c.containerType {
 	case containerArray:
+		statsHit("Container/Clone/Array")
 		other.array = make([]uint16, len(c.array))
 		copy(other.array, c.array)
 	case containerBitmap:
+		statsHit("Container/Clone/Bitmap")
 		other.bitmap = make([]uint64, len(c.bitmap))
 		copy(other.bitmap, c.bitmap)
 	case containerRun:
+		statsHit("Container/Clone/Run")
 		other.runs = make([]interval16, len(c.runs))
 		copy(other.runs, c.runs)
 	}
@ -1689,6 +1717,7 @@ func (c *Container) WriteTo(w io.Writer) (n int64, err error) {
 }

 func (c *Container) arrayWriteTo(w io.Writer) (n int64, err error) {
+	statsHit("Container/arrayWriteTo")
 	if len(c.array) == 0 {
 		return 0, nil
 	}
@ -1705,12 +1734,14 @@ func (c *Container) arrayWriteTo(w io.Writer) (n int64, err error) {
 }

 func (c *Container) bitmapWriteTo(w io.Writer) (n int64, err error) {
+	statsHit("Container/bitmapWriteTo")
 	// Write sizeof(uint64) * bitmapN bytes.
 	nn, err := w.Write((*[0xFFFFFFF]byte)(unsafe.Pointer(&c.bitmap[0]))[:(8 * bitmapN)])
 	return int64(nn), err
 }

 func (c *Container) runWriteTo(w io.Writer) (n int64, err error) {
+	statsHit("Container/runWriteTo")
 	if len(c.runs) == 0 {
 		return 0, nil
 	}
@ -1815,6 +1846,7 @@ func flip(a *Container) *Container { // nolint: deadcode
 }

 func flipArray(b *Container) *Container {
+	statsHit("flipArray")
 	// TODO: actually implement this
 	x := b.Clone()
 	x.arrayToBitmap()
@ -1822,6 +1854,7 @@ func flipArray(b *Container) *Container {
 }

 func flipBitmap(b *Container) *Container {
+	statsHit("flipBitmap")
 	other := &Container{bitmap: make([]uint64, bitmapN), containerType: containerBitmap}

 	for i, bitmap := range b.bitmap {
@ -1833,6 +1866,7 @@ func flipBitmap(b *Container) *Container {
 }

 func flipRun(b *Container) *Container {
+	statsHit("flipRun")
 	// TODO: actually implement this
 	x := b.Clone()
 	x.runToBitmap()
@ -1868,22 +1902,33 @@ func intersectionCount(a, b *Container) int32 {
 }

 func intersectionCountArrayArray(a, b *Container) (n int32) {
-	na, nb := len(a.array), len(b.array)
-	for i, j := 0, 0; i < na && j < nb; {
-		va, vb := a.array[i], b.array[j]
-		if va < vb {
-			i++
-		} else if va > vb {
+	statsHit("intersectionCount/ArrayArray")
+	ca, cb := a.array, b.array
+	na, nb := len(ca), len(cb)
+	if na == 0 || nb == 0 {
+		return 0
+	}
+	if na > nb {
+		ca, cb = cb, ca
+		na, nb = nb, na // nolint: ineffassign
+	}
+	j := 0
+	for _, va := range ca {
+		for cb[j] < va {
 			j++
-		} else {
+			if j >= nb {
+				return n
+			}
+		}
+		if cb[j] == va {
 			n++
-			i, j = i+1, j+1
 		}
 	}
 	return n
 }

 func intersectionCountArrayRun(a, b *Container) (n int32) {
+	statsHit("intersectionCount/ArrayRun")
 	na, nb := len(a.array), len(b.runs)
 	for i, j := 0, 0; i < na && j < nb; {
 		va, vb := a.array[i], b.runs[j]
@ -1900,6 +1945,7 @@ func intersectionCountArrayRun(a, b *Container) (n int32) {
 }

 func intersectionCountRunRun(a, b *Container) (n int32) {
+	statsHit("intersectionCount/RunRun")
 	na, nb := len(a.runs), len(b.runs)
 	for i, j := 0, 0; i < na && j < nb; {
 		va, vb := a.runs[i], b.runs[j]
@ -1931,6 +1977,7 @@ func intersectionCountRunRun(a, b *Container) (n int32) {
 }

 func intersectionCountBitmapRun(a, b *Container) (n int32) {
+	statsHit("intersectionCount/BitmapRun")
 	for _, iv := range b.runs {
 		n += a.bitmapCountRange(int32(iv.start), int32(iv.last)+1)
 	}
@ -1938,6 +1985,7 @@ func intersectionCountBitmapRun(a, b *Container) (n int32) {
 }

 func intersectionCountArrayBitmap(a, b *Container) (n int32) {
+	statsHit("intersectionCount/ArrayBitmap")
 	ln := len(b.bitmap)
 	for _, val := range a.array {
 		i := int(val >> 6)
@ -1951,6 +1999,7 @@ func intersectionCountArrayBitmap(a, b *Container) (n int32) {
 }

 func intersectionCountBitmapBitmap(a, b *Container) (n int32) {
+	statsHit("intersectionCount/BitmapBitmap")
 	return int32(popcountAndSlice(a.bitmap, b.bitmap))
 }

@ -1983,6 +2032,7 @@ func intersect(a, b *Container) *Container {
 }

 func intersectArrayArray(a, b *Container) *Container {
+	statsHit("intersect/ArrayArray")
 	output := &Container{containerType: containerArray}
 	na, nb := len(a.array), len(b.array)
 	for i, j := 0, 0; i < na && j < nb; {
@ -2004,6 +2054,7 @@ func intersectArrayArray(a, b *Container) *Container {
 // container. The return is always an array container (since it's guaranteed to
 // be low-cardinality)
 func intersectArrayRun(a, b *Container) *Container {
+	statsHit("intersect/ArrayRun")
 	output := &Container{containerType: containerArray}
 	na, nb := len(a.array), len(b.runs)
 	for i, j := 0, 0; i < na && j < nb; {
@ -2023,6 +2074,7 @@ func intersectArrayRun(a, b *Container) *Container {

 // intersectRunRun computes the intersect of two run containers.
 func intersectRunRun(a, b *Container) *Container {
+	statsHit("intersect/RunRun")
 	output := &Container{containerType: containerRun}
 	na, nb := len(a.runs), len(b.runs)
 	for i, j := 0, 0; i < na && j < nb; {
@ -2059,11 +2111,12 @@ func intersectRunRun(a, b *Container) *Container {
 	return output
 }

-// intersectBitmapRun returns an array container if the run container's
-// cardinality is < ArrayMaxSize. Otherwise it returns a bitmap container.
+// intersectBitmapRun returns an array container if either container's
+// cardinality is <= ArrayMaxSize. Otherwise it returns a bitmap container.
 func intersectBitmapRun(a, b *Container) *Container {
+	statsHit("intersect/BitmapRun")
 	var output *Container
-	if b.n < ArrayMaxSize {
+	if b.n <= ArrayMaxSize || a.n <= ArrayMaxSize {
 		// output is array container
 		output = &Container{containerType: containerArray}
 		for _, iv := range b.runs {
@ -2117,14 +2170,12 @@ func intersectBitmapRun(a, b *Container) *Container {
 				valast = vastart + 63
 			}
 		}
-		if output.n < ArrayMaxSize {
-			output.bitmapToArray()
-		}
 	}
 	return output
 }

 func intersectArrayBitmap(a, b *Container) *Container {
+	statsHit("intersect/ArrayBitmap")
 	output := &Container{containerType: containerArray}
 	for _, va := range a.array {
 		bmidx := va / 64
@ -2140,6 +2191,7 @@ func intersectArrayBitmap(a, b *Container) *Container {
 }

 func intersectBitmapBitmap(a, b *Container) *Container {
+	statsHit("intersect/BitmapBitmap")
 	// local variables added to prevent BCE checks in loop
 	// see https://go101.org/article/bounds-check-elimination.html
 	var (
@ -2191,6 +2243,7 @@ func union(a, b *Container) *Container {
 }

 func unionArrayArray(a, b *Container) *Container {
+	statsHit("union/ArrayArray")
 	output := &Container{containerType: containerArray}
 	na, nb := len(a.array), len(b.array)
 	for i, j := 0, 0; ; {
@ -2224,6 +2277,7 @@ func unionArrayArray(a, b *Container) *Container {
 // unionArrayRun optimistically assumes that the result will be a run container,
 // and converts to a bitmap or array container afterwards if necessary.
 func unionArrayRun(a, b *Container) *Container {
+	statsHit("union/ArrayRun")
 	if b.n == maxContainerVal+1 {
 		return b.Clone()
 	}
@ -2281,6 +2335,7 @@ func (c *Container) runAppendInterval(v interval16) int32 {
 }

 func unionRunRun(a, b *Container) *Container {
+	statsHit("union/RunRun")
 	if a.n == maxContainerVal+1 {
 		return a.Clone()
 	}
@ -2315,6 +2370,7 @@ func unionRunRun(a, b *Container) *Container {
 }

 func unionBitmapRun(a, b *Container) *Container {
+	statsHit("union/BitmapRun")
 	if b.n == maxContainerVal+1 {
 		return b.Clone()
 	}
@ -2503,6 +2559,7 @@ func difference(a, b *Container) *Container {

 // differenceArrayArray computes the difference bween two arrays.
 func differenceArrayArray(a, b *Container) *Container {
+	statsHit("difference/ArrayArray")
 	output := &Container{containerType: containerArray}
 	na, nb := len(a.array), len(b.array)
 	for i, j := 0, 0; i < na; {
@ -2528,6 +2585,7 @@ func differenceArrayArray(a, b *Container) *Container {

 // differenceArrayRun computes the difference of an array from a run.
 func differenceArrayRun(a, b *Container) *Container {
+	statsHit("difference/ArrayRun")
 	// func (ac *arrayContainer) iandNotRun16(rc *runContainer16) container {

 	if a.n == 0 || b.n == 0 {
@ -2585,6 +2643,7 @@ func differenceArrayRun(a, b *Container) *Container {

 // differenceBitmapRun computes the difference of an bitmap from a run.
 func differenceBitmapRun(a, b *Container) *Container {
+	statsHit("difference/BitmapRun")
 	if a.n == 0 || b.n == 0 {
 		return a.Clone()
 	}
@ -2599,6 +2658,7 @@ func differenceBitmapRun(a, b *Container) *Container {
 // differenceRunArray subtracts the bits in an array container from a run
 // container.
 func differenceRunArray(a, b *Container) *Container {
+	statsHit("difference/RunArray")
 	if a.n == 0 || b.n == 0 {
 		return a.Clone()
 	}
@ -2654,6 +2714,7 @@ RUNLOOP:

 // differenceRunBitmap computes the difference of an run from a bitmap.
 func differenceRunBitmap(a, b *Container) *Container {
+	statsHit("difference/RunBitmap")
 	// If a is full, difference is the flip of b.
 	if len(a.runs) > 0 && a.runs[0].start == 0 && a.runs[0].last == 65535 {
 		return flipBitmap(b)
@ -2711,6 +2772,7 @@ func differenceRunBitmap(a, b *Container) *Container {

 // differenceRunRun computes the difference of two runs.
 func differenceRunRun(a, b *Container) *Container {
+	statsHit("difference/RunRun")
 	if a.n == 0 || b.n == 0 {
 		return a.Clone()
 	}
@ -2774,6 +2836,7 @@ func differenceRunRun(a, b *Container) *Container {
 }

 func differenceArrayBitmap(a, b *Container) *Container {
+	statsHit("difference/ArrayBitmap")
 	output := &Container{containerType: containerArray}
 	for _, va := range a.array {
 		bmidx := va / 64
@ -2790,6 +2853,7 @@ func differenceArrayBitmap(a, b *Container) *Container {
 }

 func differenceBitmapArray(a, b *Container) *Container {
+	statsHit("difference/BitmapArray")
 	output := a.Clone()

 	for _, v := range b.array {
@ -2805,6 +2869,7 @@ func differenceBitmapArray(a, b *Container) *Container {
 }

 func differenceBitmapBitmap(a, b *Container) *Container {
+	statsHit("difference/BitmapBitmap")
 	// local variables added to prevent BCE checks in loop
 	// see https://go101.org/article/bounds-check-elimination.html

@ -2862,6 +2927,7 @@ func xor(a, b *Container) *Container {
 }

 func xorArrayArray(a, b *Container) *Container {
+	statsHit("xor/ArrayArray")
 	output := &Container{containerType: containerArray}
 	na, nb := len(a.array), len(b.array)
 	for i, j := 0, 0; i < na || j < nb; {
@ -2891,6 +2957,7 @@ func xorArrayArray(a, b *Container) *Container {
 }

 func xorArrayBitmap(a, b *Container) *Container {
+	statsHit("xor/ArrayBitmap")
 	output := b.Clone()
 	for _, v := range a.array {
 		if b.bitmapContains(v) {
@ -2910,6 +2977,7 @@ func xorArrayBitmap(a, b *Container) *Container {
 }

 func xorBitmapBitmap(a, b *Container) *Container {
+	statsHit("xor/BitmapBitmap")
 	// local variables added to prevent BCE checks in loop
 	// see https://go101.org/article/bounds-check-elimination.html

@ -2987,6 +3055,7 @@ func (op *op) UnmarshalBinary(data []byte) error {
 	if len(data) < op.size() {
 		return fmt.Errorf("op data out of bounds: len=%d", len(data))
 	}
+	statsHit("op/UnmarshalBinary")

 	// Verify checksum.
 	h := fnv.New32a()
@ -3011,6 +3080,7 @@ func lowbits(v uint64) uint16  { return uint16(v & 0xFFFF) }
 // search32 returns the index of value in a. If value is not found, it works the
 // same way as search64.
 func search32(a []uint16, value uint16) int32 {
+	statsHit("search32")
 	// Optimize for elements and the last element.
 	n := int32(len(a))
 	if n == 0 {
@ -3054,6 +3124,7 @@ func search32(a []uint16, value uint16) int32 {
 // since negative 0 is no different from positive 0, we offset the returned
 // negative indices by 1. See the test for this function for examples.
 func search64(a []uint64, value uint64) int {
+	statsHit("search64")
 	// Optimize for elements and the last element.
 	n := len(a)
 	if n == 0 {
@ -3132,6 +3203,7 @@ func (a *ErrorList) AppendWithPrefix(err error, prefix string) {

 // xorArrayRun computes the exclusive or of an array and a run container.
 func xorArrayRun(a, b *Container) *Container {
+	statsHit("xor/ArrayRun")
 	output := &Container{containerType: containerRun}
 	na, nb := len(a.array), len(b.runs)
 	var vb interval16
@ -3290,6 +3362,7 @@ type xorstm struct {

 // xorRunRun computes the exclusive or of two run containers.
 func xorRunRun(a, b *Container) *Container {
+	statsHit("xor/RunRun")
 	na, nb := len(a.runs), len(b.runs)
 	if na == 0 {
 		return b.Clone()
@ -3338,6 +3411,7 @@ func xorRunRun(a, b *Container) *Container {

 // xorRunRun computes the exclusive or of a bitmap and a run container.
 func xorBitmapRun(a, b *Container) *Container {
+	statsHit("xor/BitmapRun")
 	output := a.Clone()
 	for j := 0; j < len(b.runs); j++ {
 		output.bitmapXorRange(uint64(b.runs[j].start), uint64(b.runs[j].last)+1)
@ -3352,6 +3426,7 @@ func xorBitmapRun(a, b *Container) *Container {
 }

 func bitmapsEqual(b, c *Bitmap) error { // nolint: deadcode
+	statsHit("bitmapsEqual")
 	if b.OpWriter != c.OpWriter {
 		return errors.New("opWriters not equal")
 	}
@ -3404,6 +3479,7 @@ const (
 )

 func readOfficialHeader(buf []byte) (size uint32, containerTyper func(index uint, card int) byte, header, pos int, haveRuns bool, err error) {
+	statsHit("readOfficialHeader")
 	if len(buf) < 8 {
 		err = fmt.Errorf("buffer too small, expecting at least 8 bytes, was %d", len(buf))
 		return size, containerTyper, header, pos, haveRuns, err
@ -3465,6 +3541,11 @@ func readOfficialHeader(buf []byte) (size uint32, containerTyper func(index uint
 // UnmarshalBinary decodes b from a binary-encoded byte slice. data can be in
 // either official roaring format or Pilosa's roaring format.
 func (b *Bitmap) UnmarshalBinary(data []byte) error {
+	if data == nil {
+		// Nothing to unmarshal
+		return nil
+	}
+	statsHit("Bitmap/UnmarshalBinary")
 	fileMagic := uint32(binary.LittleEndian.Uint16(data[0:2]))
 	if fileMagic == magicNumber { // if pilosa roaring
 		return errors.Wrap(b.unmarshalPilosaRoaring(data), "unmarshaling as pilosa roaring")
--- a/roaring/roaring_internal_test.go
+++ b/roaring/roaring_internal_test.go
@ -165,8 +165,8 @@ func TestRunCountRange(t *testing.T) {
 	}

 	c.add(17)
-	c.add(18)
 	c.add(19)
+	c.add(18)

 	cnt = c.runCountRange(1, 22)
 	if cnt != 10 {
@ -180,6 +180,11 @@ func TestRunCountRange(t *testing.T) {
 	if cnt != 9 {
 		t.Fatalf("should get 9 from multiple ranges overlapping both sides, but got: %v", cnt)
 	}
+	// verify that the disparate ops resulted in three separate runs
+	cnt = c.countRuns()
+	if cnt != 3 {
+		t.Fatalf("should get 3 total runs, but got: %v [%v]", cnt, c.runs)
+	}
 }

 func TestRunContains(t *testing.T) {
@ -3261,3 +3266,26 @@ func TestUnmarshalOfficialRoaring(t *testing.T) {
 	}

 }
+
+/*
+// This function exercises an arcane edge case in dead code.
+// It doesn't need to be run right now.
+func TestEquals(t *testing.T) {
+	bma := NewBitmap()
+	bmr := NewBitmap()
+	for i := uint64(0); i < 30; i++ {
+		bma.Add(i)
+		bmr.Add(i)
+	}
+	bmr.Optimize()
+	bmi := bma.Intersect(bmr)
+	err := bitmapsEqual(bmi, bma)
+	if err != nil {
+		t.Fatalf("expected intersection to equal array")
+	}
+	err = bitmapsEqual(bmi, bmr)
+	if err != nil {
+		t.Fatalf("expected intersection to equal run")
+	}
+}
+*/
--- a/roaring/roaring_nop_stats.go
+++ b/roaring/roaring_nop_stats.go
@ -0,0 +1,8 @@
+// +build !roaringstats
+
+package roaring
+
+// statsCount does nothing, because you aren't building with
+// the "roaringstats" build tag.
+func statsHit(string) {
+}
--- a/roaring/roaring_stats.go
+++ b/roaring/roaring_stats.go
@ -0,0 +1,15 @@
+// +build roaringstats
+
+package roaring
+
+import (
+	"github.com/pilosa/pilosa/stats"
+)
+
+var statsEv = stats.NewExpvarStatsClient()
+
+// statsHit increments the given stat, so we can tell how often we've hit
+// that particular event.
+func statsHit(name string) {
+	statsEv.Count(name, 1, 1)
+}
--- a/roaring/roaring_test.go
+++ b/roaring/roaring_test.go
@ -411,13 +411,29 @@ func TestBitmap_Intersection_Empty(t *testing.T) {
 }

 func TestBitmap_IntersectArrayArray(t *testing.T) {
-	bm0 := roaring.NewFileBitmap(0, 1, 2683, 5005)
+	bm0 := roaring.NewFileBitmap(0, 1, 7, 9, 11, 2683, 5005)
 	bm1 := roaring.NewFileBitmap(0, 2683, 2684, 5000)
+	expected := []uint64{0, 2683}

 	result := bm0.Intersect(bm1)
 	if n := result.Count(); n != 2 {
 		t.Fatalf("unexpected n: %d", n)
 	}
+	for _, e := range expected {
+		if !result.Contains(e) {
+			t.Fatalf("missing value %d", e)
+		}
+	}
+	// confirm that it also works going the other way
+	result = bm1.Intersect(bm0)
+	if n := result.Count(); n != 2 {
+		t.Fatalf("unexpected n: %d", n)
+	}
+	for _, e := range expected {
+		if !result.Contains(e) {
+			t.Fatalf("missing value %d", e)
+		}
+	}
 }

 func TestBitmap_IntersectBitmapBitmap(t *testing.T) {
@ -689,10 +705,10 @@ func TestBitmap_Flip_After(t *testing.T) {

 }

-// Ensure bitmap can return the number of intersecting bits in two bitmaps.
+// Ensure bitmap can return the number of intersecting bits in two arrays.
 func TestBitmap_IntersectionCount_ArrayArray(t *testing.T) {
-	bm0 := roaring.NewFileBitmap(0, 1, 1000001, 1000002, 1000003)
-	bm1 := roaring.NewFileBitmap(0, 50000, 1000001, 1000002)
+	bm0 := roaring.NewFileBitmap(0, 1000001, 1000002, 1000003)
+	bm1 := roaring.NewFileBitmap(0, 50000, 999998, 999999, 1000000, 1000001, 1000002)

 	if n := bm0.IntersectionCount(bm1); n != 3 {
 		t.Fatalf("unexpected n: %d", n)
@ -1056,19 +1072,39 @@ func TestBitmapBufIterator(t *testing.T) {

 }

-var benchmarkBitmapIntersectionCountData struct {
-	a, b, r *roaring.Bitmap
+// this data is used to test various operations across
+// different types.
+type benchmarkSampleData struct {
+	a1, a2, b, r1, r2 *roaring.Bitmap
 }

-func getBenchData() *struct{ a, b, r *roaring.Bitmap } {
-	data := &benchmarkBitmapIntersectionCountData
-	if data.a == nil {
+var sampleData benchmarkSampleData
+
+func isAllType(b *roaring.Bitmap, typ string) bool {
+	bi := b.Info()
+	for _, c := range bi.Containers {
+		if c.Type != typ {
+			return false
+		}
+	}
+	return true
+}
+
+func getBenchData(b *testing.B) *benchmarkSampleData {
+	data := &sampleData
+	if data.a1 == nil {
 		const max = (1 << 24) / 64

 		// Build bitmap with array container.
-		data.a = roaring.NewFileBitmap()
-		for i, n := 0, 2*roaring.ArrayMaxSize/3; i < n; i++ {
-			data.a.Add(uint64(rand.Intn(max)))
+		data.a1 = roaring.NewFileBitmap()
+		data.a2 = roaring.NewFileBitmap()
+		// two lists of different lengths
+		for i, n := 0, roaring.ArrayMaxSize/3; i < n; i++ {
+			data.a1.Add(uint64(rand.Intn(max)))
+			data.a2.Add(uint64(rand.Intn(max)))
+		}
+		for i, n := 0, roaring.ArrayMaxSize/3; i < n; i++ {
+			data.a1.Add(uint64(rand.Intn(max)))
 		}

 		// Build bitmap with bitmap container.
@ -1078,12 +1114,42 @@ func getBenchData() *struct{ a, b, r *roaring.Bitmap } {
 		}

 		// build bitmap with run container
-		data.r = roaring.NewFileBitmap()
+		data.r1 = roaring.NewFileBitmap()
 		for i, n := 0, MaxContainerVal; i < n; i++ {
-			data.r.Add(uint64(i))
+			data.r1.Add(uint64(i))
 		}
+		// build bitmap with multiple runs
+		data.r2 = roaring.NewFileBitmap()
+		for i, n := 0, MaxContainerVal; i < n; i++ {
+			data.r2.Add(uint64(i))
+			// break the runs up, this should produce 16 runs, which
+			// is small enough to make RLE tempting
+			if i&0xfff == 0xfff {
+				i += 5
+			}
+		}
+		data.a1.Optimize()
+		data.a2.Optimize()
+		data.b.Optimize()
+		data.r1.Optimize()
+		data.r2.Optimize()

 	}
+	if !isAllType(data.a1, "array") {
+		b.Fatalf("expected data.a1 to be an array, it wasn't.")
+	}
+	if !isAllType(data.a2, "array") {
+		b.Fatalf("expected data.a2 to be an array, it wasn't.")
+	}
+	if !isAllType(data.b, "bitmap") {
+		b.Fatalf("expected data.b to be a bitmap, it wasn't.")
+	}
+	if !isAllType(data.r1, "run") {
+		b.Fatalf("expected data.r1 to be RLE, it wasn't.")
+	}
+	if !isAllType(data.r2, "run") {
+		b.Fatalf("expected data.r2 to be RLE, it wasn't.")
+	}
 	return data
 }

@ -1138,30 +1204,65 @@ func TestBitmap_Intersect(t *testing.T) {
 	}
 }

+func BenchmarkGetBenchData(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		sampleData = benchmarkSampleData{}
+		getBenchData(b)
+	}
+}
+
 func BenchmarkBitmap_IntersectionCount_ArrayRun(b *testing.B) {
-	data := getBenchData()
+	data := getBenchData(b)
 	// Reset timer & benchmark.
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		data.a.IntersectionCount(data.r)
+		data.a1.IntersectionCount(data.r1)
+	}
+}
+
+func BenchmarkBitmap_IntersectionCount_ArrayRuns(b *testing.B) {
+	data := getBenchData(b)
+	// Reset timer & benchmark.
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		data.a1.IntersectionCount(data.r2)
 	}
 }

 func BenchmarkBitmap_IntersectionCount_BitmapRun(b *testing.B) {
-	data := getBenchData()
+	data := getBenchData(b)
 	// Reset timer & benchmark.
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		data.b.IntersectionCount(data.r)
+		data.b.IntersectionCount(data.r1)
+	}
+}
+
+func BenchmarkBitmap_IntersectionCount_BitmapRuns(b *testing.B) {
+	data := getBenchData(b)
+	// Reset timer & benchmark.
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		data.b.IntersectionCount(data.r2)
+	}
+}
+
+func BenchmarkBitmap_IntersectionCount_ArrayArray(b *testing.B) {
+	data := getBenchData(b)
+	// Reset timer & benchmark.
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		data.a1.IntersectionCount(data.a2)
+		data.a2.IntersectionCount(data.a1)
 	}
 }

 func BenchmarkBitmap_IntersectionCount_ArrayBitmap(b *testing.B) {
-	data := getBenchData()
+	data := getBenchData(b)
 	// Reset timer & benchmark.
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		data.a.IntersectionCount(data.b)
+		data.a1.IntersectionCount(data.b)
 	}
 }

--- a/server.go
+++ b/server.go
@ -27,7 +27,9 @@ import (
 	"sync"
 	"time"

+	"github.com/pilosa/pilosa/logger"
 	"github.com/pilosa/pilosa/roaring"
+	"github.com/pilosa/pilosa/stats"
 	"github.com/pkg/errors"
 	"golang.org/x/sync/errgroup"
 )
@ -58,7 +60,7 @@ type Server struct { // nolint: maligned
 	// External
 	systemInfo SystemInfo
 	gcNotifier GCNotifier
-	logger     Logger
+	logger     logger.Logger

 	nodeID              string
 	uri                 URI
@ -81,7 +83,7 @@ func (s *Server) Holder() *Holder {
 // ServerOption is a functional option type for pilosa.Server
 type ServerOption func(s *Server) error

-func OptServerLogger(l Logger) ServerOption {
+func OptServerLogger(l logger.Logger) ServerOption {
 	return func(s *Server) error {
 		s.logger = l
 		return nil
@ -176,7 +178,7 @@ func OptServerPrimaryTranslateStoreFunc(tf func(interface{}) TranslateStore) Ser
 	}
 }

-func OptServerStatsClient(sc StatsClient) ServerOption {
+func OptServerStatsClient(sc stats.StatsClient) ServerOption {
 	return func(s *Server) error {
 		s.holder.Stats = sc
 		return nil
@ -258,7 +260,7 @@ func NewServer(opts ...ServerOption) (*Server, error) {
 		metricInterval:      0,
 		diagnosticInterval:  0,

-		logger: NopLogger,
+		logger: logger.NopLogger,
 	}
 	s.executor = newExecutor(optExecutorInternalQueryClient(s.defaultClient))
 	s.cluster.InternalClient = s.defaultClient
@ -298,6 +300,7 @@ func NewServer(opts ...ServerOption) (*Server, error) {
 		ID:            s.nodeID,
 		URI:           s.uri,
 		IsCoordinator: s.cluster.Coordinator == s.nodeID,
+		State:         nodeStateDown,
 	}
 	s.cluster.Node = node
 	if s.clusterDisabled {
@ -561,7 +564,10 @@ func (s *Server) receiveMessage(m Message) error {
 	case *RecalculateCaches:
 		s.holder.recalculateCaches()
 	case *NodeEvent:
-		s.cluster.ReceiveEvent(obj)
+		err := s.cluster.ReceiveEvent(obj)
+		if err != nil {
+			return errors.Wrapf(err, "cluster receiving NodeEvent %v", obj)
+		}
 	case *NodeStatus:
 		s.handleRemoteStatus(obj)
 	}
--- a/server/server.go
+++ b/server/server.go
@ -11,7 +11,7 @@
 // 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 server contains the `pilosa server` subcommand which runs Pilosa
 // itself. The purpose of this package is to define an easily tested Command
 // object which handles interpreting configuration and setting up all the
@ -20,6 +20,7 @@
 package server

 import (
+	"bytes"
 	"crypto/tls"
 	"io"
 	"log"
@ -40,12 +41,14 @@ import (
 	"github.com/pilosa/pilosa/gopsutil"
 	"github.com/pilosa/pilosa/gossip"
 	"github.com/pilosa/pilosa/http"
+	"github.com/pilosa/pilosa/logger"
+	"github.com/pilosa/pilosa/stats"
 	"github.com/pilosa/pilosa/statsd"
 	"github.com/pkg/errors"
 )

 type loggerLogger interface {
-	pilosa.Logger
+	logger.Logger
 	Logger() *log.Logger
 }

@ -184,9 +187,9 @@ func (m *Command) setupLogger() error {
 	}

 	if m.Config.Verbose {
-		m.logger = pilosa.NewVerboseLogger(m.logOutput)
+		m.logger = logger.NewVerboseLogger(m.logOutput)
 	} else {
-		m.logger = pilosa.NewStandardLogger(m.logOutput)
+		m.logger = logger.NewStandardLogger(m.logOutput)
 	}
 	return nil
 }
@ -336,7 +339,7 @@ func (m *Command) setupNetworking() error {
 	gossipMemberSet, err := gossip.NewMemberSet(
 		m.Config.Gossip,
 		m.API,
-		gossip.WithLogger(m.logger.Logger()),
+		gossip.WithLogOutput(&filteredWriter{logOutput: m.logOutput, v: m.Config.Verbose}),
 		gossip.WithTransport(m.gossipTransport),
 	)
 	if err != nil {
@ -374,14 +377,14 @@ func (m *Command) Close() error {
 }

 // newStatsClient creates a stats client from the config
-func newStatsClient(name string, host string) (pilosa.StatsClient, error) {
+func newStatsClient(name string, host string) (stats.StatsClient, error) {
 	switch name {
 	case "expvar":
-		return pilosa.NewExpvarStatsClient(), nil
+		return stats.NewExpvarStatsClient(), nil
 	case "statsd":
 		return statsd.NewStatsClient(host)
 	case "nop", "none":
-		return pilosa.NopStatsClient, nil
+		return stats.NopStatsClient, nil
 	default:
 		return nil, errors.Errorf("'%v' not a valid stats client, choose from [expvar, statsd, none].", name)
 	}
@ -407,3 +410,24 @@ func getListener(uri pilosa.URI, tlsconf *tls.Config) (ln net.Listener, err erro

 	return ln, nil
 }
+
+type filteredWriter struct {
+	v         bool
+	logOutput io.Writer
+}
+
+// Write forwards the write to logOutput if verbose is true, or it doesn't
+// contain [DEBUG] or [INFO]. This implementation isn't technically correct
+// since Write could be called with only part of a log line, but I don't think
+// that actually happens, so until it becomes a problem, I don't think it's
+// worth dealing with the extra complexity. (jaffee)
+func (f *filteredWriter) Write(p []byte) (n int, err error) {
+	if bytes.Contains(p, []byte("[DEBUG]")) || bytes.Contains(p, []byte("[INFO]")) {
+		if f.v {
+			return f.logOutput.Write(p)
+		}
+	} else {
+		return f.logOutput.Write(p)
+	}
+	return len(p), nil
+}
--- a/stats/stats.go
+++ b/stats/stats.go
@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-package pilosa
+package stats

 import (
 	"expvar"
@ -20,6 +20,8 @@ import (
 	"strings"
 	"sync"
 	"time"
+
+	"github.com/pilosa/pilosa/logger"
 )

 // Expvar global expvar map.
@ -52,7 +54,7 @@ type StatsClient interface {
 	Timing(name string, value time.Duration, rate float64)

 	// SetLogger Set the logger output type
-	SetLogger(logger Logger)
+	SetLogger(logger logger.Logger)

 	// Starts the service
 	Open()
@ -74,7 +76,7 @@ func (c *nopStatsClient) Gauge(name string, value float64, rate float64)
 func (c *nopStatsClient) Histogram(name string, value float64, rate float64)                        {}
 func (c *nopStatsClient) Set(name string, value string, rate float64)                               {}
 func (c *nopStatsClient) Timing(name string, value time.Duration, rate float64)                     {}
-func (c *nopStatsClient) SetLogger(logger Logger)                                                   {}
+func (c *nopStatsClient) SetLogger(logger logger.Logger)                                            {}
 func (c *nopStatsClient) Open()                                                                     {}
 func (c *nopStatsClient) Close() error                                                              { return nil }

@ -149,7 +151,7 @@ func (c *expvarStatsClient) Timing(name string, value time.Duration, rate float6
 }

 // SetLogger has no logger.
-func (c *expvarStatsClient) SetLogger(logger Logger) {
+func (c *expvarStatsClient) SetLogger(logger logger.Logger) {
 }

 // Open no-op.
@ -221,7 +223,7 @@ func (a MultiStatsClient) Timing(name string, value time.Duration, rate float64)
 }

 // SetLogger Sets the StatsD logger output type.
-func (a MultiStatsClient) SetLogger(logger Logger) {
+func (a MultiStatsClient) SetLogger(logger logger.Logger) {
 	for _, c := range a {
 		c.SetLogger(logger)
 	}
--- a/stats/stats_test.go
+++ b/stats/stats_test.go
@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.

-package pilosa_test
+package stats_test

 import (
 	"context"
@ -23,6 +23,8 @@ import (

 	"github.com/pilosa/pilosa"
 	"github.com/pilosa/pilosa/http"
+	"github.com/pilosa/pilosa/logger"
+	"github.com/pilosa/pilosa/stats"
 	"github.com/pilosa/pilosa/test"
 )

@ -32,51 +34,51 @@ func TestMultiStatClient_Expvar(t *testing.T) {
 	hldr := test.MustOpenHolder()
 	defer hldr.Close()

-	c := pilosa.NewExpvarStatsClient()
-	ms := make(pilosa.MultiStatsClient, 1)
+	c := stats.NewExpvarStatsClient()
+	ms := make(stats.MultiStatsClient, 1)
 	ms[0] = c
 	hldr.Stats = ms

 	hldr.SetBit("d", "f", 0, 0)
 	hldr.SetBit("d", "f", 0, 1)
-	hldr.SetBit("d", "f", 0, ShardWidth)
-	hldr.SetBit("d", "f", 0, ShardWidth+2)
+	hldr.SetBit("d", "f", 0, pilosa.ShardWidth)
+	hldr.SetBit("d", "f", 0, pilosa.ShardWidth+2)
 	hldr.ClearBit("d", "f", 0, 1)

-	if pilosa.Expvar.String() != `{"index:d": {"field:f": {"view:standard": {"shard:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "shard:1": {"rows": 0, "setBit": 2}}}}}` {
-		t.Fatalf("unexpected expvar : %s", pilosa.Expvar.String())
+	if stats.Expvar.String() != `{"index:d": {"field:f": {"view:standard": {"shard:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "shard:1": {"rows": 0, "setBit": 2}}}}}` {
+		t.Fatalf("unexpected expvar : %s", stats.Expvar.String())
 	}

 	hldr.Stats.CountWithCustomTags("cc", 1, 1.0, []string{"foo:bar"})
-	if pilosa.Expvar.String() != `{"cc": 1, "index:d": {"field:f": {"view:standard": {"shard:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "shard:1": {"rows": 0, "setBit": 2}}}}}` {
-		t.Fatalf("unexpected expvar : %s", pilosa.Expvar.String())
+	if stats.Expvar.String() != `{"cc": 1, "index:d": {"field:f": {"view:standard": {"shard:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "shard:1": {"rows": 0, "setBit": 2}}}}}` {
+		t.Fatalf("unexpected expvar : %s", stats.Expvar.String())
 	}

 	// Gauge creates a unique key, subsequent Gauge calls will overwrite
 	hldr.Stats.Gauge("g", 5, 1.0)
 	hldr.Stats.Gauge("g", 8, 1.0)
-	if pilosa.Expvar.String() != `{"cc": 1, "g": 8, "index:d": {"field:f": {"view:standard": {"shard:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "shard:1": {"rows": 0, "setBit": 2}}}}}` {
-		t.Fatalf("unexpected expvar : %s", pilosa.Expvar.String())
+	if stats.Expvar.String() != `{"cc": 1, "g": 8, "index:d": {"field:f": {"view:standard": {"shard:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "shard:1": {"rows": 0, "setBit": 2}}}}}` {
+		t.Fatalf("unexpected expvar : %s", stats.Expvar.String())
 	}

 	// Set creates a unique key, subsequent sets will overwrite
 	hldr.Stats.Set("s", "4", 1.0)
 	hldr.Stats.Set("s", "7", 1.0)
-	if pilosa.Expvar.String() != `{"cc": 1, "g": 8, "index:d": {"field:f": {"view:standard": {"shard:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "shard:1": {"rows": 0, "setBit": 2}}}}, "s": "7"}` {
-		t.Fatalf("unexpected expvar : %s", pilosa.Expvar.String())
+	if stats.Expvar.String() != `{"cc": 1, "g": 8, "index:d": {"field:f": {"view:standard": {"shard:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "shard:1": {"rows": 0, "setBit": 2}}}}, "s": "7"}` {
+		t.Fatalf("unexpected expvar : %s", stats.Expvar.String())
 	}

 	// Record timing duration and a uniquely Set key/value
 	dur, _ := time.ParseDuration("123us")
 	hldr.Stats.Timing("tt", dur, 1.0)
-	if pilosa.Expvar.String() != `{"cc": 1, "g": 8, "index:d": {"field:f": {"view:standard": {"shard:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "shard:1": {"rows": 0, "setBit": 2}}}}, "s": "7", "tt": 123µs}` {
-		t.Fatalf("unexpected expvar : %s", pilosa.Expvar.String())
+	if stats.Expvar.String() != `{"cc": 1, "g": 8, "index:d": {"field:f": {"view:standard": {"shard:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "shard:1": {"rows": 0, "setBit": 2}}}}, "s": "7", "tt": 123µs}` {
+		t.Fatalf("unexpected expvar : %s", stats.Expvar.String())
 	}

 	// Expvar histogram is implemented as a gauge
 	hldr.Stats.Histogram("hh", 3, 1.0)
-	if pilosa.Expvar.String() != `{"cc": 1, "g": 8, "hh": 3, "index:d": {"field:f": {"view:standard": {"shard:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "shard:1": {"rows": 0, "setBit": 2}}}}, "s": "7", "tt": 123µs}` {
-		t.Fatalf("unexpected expvar : %s", pilosa.Expvar.String())
+	if stats.Expvar.String() != `{"cc": 1, "g": 8, "hh": 3, "index:d": {"field:f": {"view:standard": {"shard:0": {"clearBit": 1, "rows": 0, "setBit": 2}, "shard:1": {"rows": 0, "setBit": 2}}}}, "s": "7", "tt": 123µs}` {
+		t.Fatalf("unexpected expvar : %s", stats.Expvar.String())
 	}

 	// Expvar should ignore earlier set tags from setbit
@ -92,8 +94,8 @@ func TestStatsCount_TopN(t *testing.T) {

 	hldr.SetBit("d", "f", 0, 0)
 	hldr.SetBit("d", "f", 0, 1)
-	hldr.SetBit("d", "f", 0, ShardWidth)
-	hldr.SetBit("d", "f", 0, ShardWidth+2)
+	hldr.SetBit("d", "f", 0, pilosa.ShardWidth)
+	hldr.SetBit("d", "f", 0, pilosa.ShardWidth+2)

 	// Execute query.
 	called := false
@ -311,11 +313,11 @@ func (s *MockStats) CountWithCustomTags(name string, value int64, rate float64,
 }

 func (c *MockStats) Tags() []string                                        { return nil }
-func (c *MockStats) WithTags(tags ...string) pilosa.StatsClient            { return c }
+func (c *MockStats) WithTags(tags ...string) stats.StatsClient             { return c }
 func (c *MockStats) Gauge(name string, value float64, rate float64)        {}
 func (c *MockStats) Histogram(name string, value float64, rate float64)    {}
 func (c *MockStats) Set(name string, value string, rate float64)           {}
 func (c *MockStats) Timing(name string, value time.Duration, rate float64) {}
-func (c *MockStats) SetLogger(logger pilosa.Logger)                        {}
+func (c *MockStats) SetLogger(logger logger.Logger)                        {}
 func (c *MockStats) Open()                                                 {}
 func (c *MockStats) Close() error                                          { return nil }
--- a/statsd/statsd.go
+++ b/statsd/statsd.go
@ -19,7 +19,8 @@ import (
 	"time"

 	"github.com/DataDog/datadog-go/statsd"
-	"github.com/pilosa/pilosa"
+	"github.com/pilosa/pilosa/logger"
+	"github.com/pilosa/pilosa/stats"
 )

 // StatsD protocol wrapper using the DataDog library that added Tags to the StatsD protocol
@ -34,13 +35,13 @@ const (
 )

 // Ensure client implements interface.
-var _ pilosa.StatsClient = &statsClient{}
+var _ stats.StatsClient = &statsClient{}

 // statsClient represents a StatsD implementation of pilosa.statsClient.
 type statsClient struct {
 	client *statsd.Client
 	tags   []string
-	logger pilosa.Logger
+	logger logger.Logger
 }

 // NewStatsClient returns a new instance of StatsClient.
@ -52,7 +53,7 @@ func NewStatsClient(host string) (*statsClient, error) {

 	return &statsClient{
 		client: c,
-		logger: pilosa.NopLogger,
+		logger: logger.NopLogger,
 	}, nil
 }

@ -70,7 +71,7 @@ func (c *statsClient) Tags() []string {
 }

 // WithTags returns a new client with additional tags appended.
-func (c *statsClient) WithTags(tags ...string) pilosa.StatsClient {
+func (c *statsClient) WithTags(tags ...string) stats.StatsClient {
 	return &statsClient{
 		client: c.client,
 		tags:   unionStringSlice(c.tags, tags),
@ -122,7 +123,7 @@ func (c *statsClient) Timing(name string, value time.Duration, rate float64) {
 }

 // SetLogger sets the logger for client.
-func (c *statsClient) SetLogger(logger pilosa.Logger) {
+func (c *statsClient) SetLogger(logger logger.Logger) {
 	c.logger = logger
 }

--- a/translate.go
+++ b/translate.go
@ -15,6 +15,7 @@ import (
 	"time"

 	"github.com/cespare/xxhash"
+	"github.com/pilosa/pilosa/logger"
 	"github.com/pkg/errors"
 )

@ -68,7 +69,7 @@ type TranslateFile struct {

 	Path    string
 	mapSize int
-	logger  Logger
+	logger  logger.Logger
 	// If non-nil, data is streamed from a primary and this is a read-only store.
 	PrimaryTranslateStore TranslateStore
 	primaryID             string // unique ID used to identify the primary store
@ -89,7 +90,7 @@ func OptTranslateFileMapSize(mapSize int) TranslateFileOption {
 		return nil
 	}
 }
-func OptTranslateFileLogger(l Logger) TranslateFileOption {
+func OptTranslateFileLogger(l logger.Logger) TranslateFileOption {
 	return func(s *TranslateFile) error {
 		s.logger = l
 		return nil
@ -116,7 +117,7 @@ func NewTranslateFile(opts ...TranslateFileOption) *TranslateFile {

 		mapSize: defaultMapSize,

-		logger: NopLogger,
+		logger: logger.NopLogger,

 		replicationClosing: make(chan struct{}),
 		primaryStoreEvents: make(chan primaryStoreEvent),
--- a/translate_test.go
+++ b/translate_test.go
@ -809,7 +809,7 @@ func NewTranslateFile() *TranslateFile {
 	}
 	f.Close()

-	s := &TranslateFile{TranslateFile: pilosa.NewTranslateFile(pilosa.OptTranslateFileMapSize(2 << 25))}
+	s := &TranslateFile{TranslateFile: pilosa.NewTranslateFile(pilosa.OptTranslateFileMapSize(2 << 26))}
 	s.Path = f.Name()
 	return s
 }
--- a/view.go
+++ b/view.go
@ -22,8 +22,10 @@ import (
 	"strings"
 	"sync"

+	"github.com/pilosa/pilosa/logger"
 	"github.com/pilosa/pilosa/pql"
 	"github.com/pilosa/pilosa/roaring"
+	"github.com/pilosa/pilosa/stats"
 	"github.com/pkg/errors"
 )

@ -50,9 +52,9 @@ type view struct {
 	fragments map[uint64]*fragment

 	broadcaster  broadcaster
-	stats        StatsClient
+	stats        stats.StatsClient
 	rowAttrStore AttrStore
-	logger       Logger
+	logger       logger.Logger
 }

 // newView returns a new instance of View.
@ -70,8 +72,8 @@ func newView(path, index, field, name string, fieldOptions FieldOptions) *view {
 		fragments: make(map[uint64]*fragment),

 		broadcaster: NopBroadcaster,
-		stats:       NopStatsClient,
-		logger:      NopLogger,
+		stats:       stats.NopStatsClient,
+		logger:      logger.NopLogger,
 	}
 }