diff --git a/writer.go b/client.go similarity index 50% rename from writer.go rename to client.go index 2cc358b..975a764 100644 --- a/writer.go +++ b/client.go @@ -33,42 +33,33 @@ var EraseFileOnStop = false var writerlog = log.WithField("prefix", "writer") -// Writer defines the interface of a MMV file writer's properties -type Writer interface { - // a writer must contain a registry of metrics and instance domains +// Client defines the interface for a type that can talk to an instrumentation agent +type Client interface { + // a client must contain a registry of metrics Registry() Registry - // writes an mmv file + // starts monitoring Start() error // Start that will panic on failure MustStart() - // stops writing and cleans up + // stop monitoring Stop() error // Stop that will panic on failure MustStop() - // returns the number of bytes that will be written by the current writer - Length() int - - // adds a metric to be written + // adds a metric to be monitored Register(Metric) error // tries to add a metric to be written and panics on error MustRegister(Metric) - // adds an instance domain to be written - RegisterIndom(InstanceDomain) error - - // tries to add an indom and panics on error - MustRegisterIndom(InstanceDomain) - - // adds metric and instance domain from a string + // adds metric from a string RegisterString(string, interface{}, MetricSemantics, MetricType, MetricUnit) error - // tries to add a metric and an instance domain from a string and panics on an error + // tries to add a metric from a string and panics on an error MustRegisterString(string, interface{}, MetricSemantics, MetricType, MetricUnit) error } @@ -106,8 +97,8 @@ const ( //go:generate stringer -type=MMVFlag -// PCPWriter implements a writer that can write PCP compatible MMV files -type PCPWriter struct { +// PCPClient implements a client that can generate instrumentation for PCP +type PCPClient struct { sync.Mutex loc string // absolute location of the mmv file clusterID uint32 // cluster identifier for the writer @@ -116,8 +107,8 @@ type PCPWriter struct { buffer bytebuffer.Buffer // current Buffer } -// NewPCPWriter initializes a new PCPWriter object -func NewPCPWriter(name string, flag MMVFlag) (*PCPWriter, error) { +// NewPCPClient initializes a new PCPClient object +func NewPCPClient(name string, flag MMVFlag) (*PCPClient, error) { fileLocation, err := mmvFileLocation(name) if err != nil { return nil, err @@ -125,7 +116,7 @@ func NewPCPWriter(name string, flag MMVFlag) (*PCPWriter, error) { writerlog.WithField("location", fileLocation).Info("deduced location to write the MMV file") - return &PCPWriter{ + return &PCPClient{ loc: fileLocation, r: NewPCPRegistry(), clusterID: hash(name, PCPClusterIDBitLength), @@ -135,18 +126,18 @@ func NewPCPWriter(name string, flag MMVFlag) (*PCPWriter, error) { } // Registry returns a writer's registry -func (w *PCPWriter) Registry() Registry { - return w.r +func (c *PCPClient) Registry() Registry { + return c.r } -func (w *PCPWriter) tocCount() int { +func (c *PCPClient) tocCount() int { ans := 2 - if w.Registry().InstanceCount() > 0 { + if c.Registry().InstanceCount() > 0 { ans += 2 } - if w.Registry().StringCount() > 0 { + if c.Registry().StringCount() > 0 { ans++ } @@ -154,18 +145,18 @@ func (w *PCPWriter) tocCount() int { } // Length returns the byte length of data in the mmv file written by the current writer -func (w *PCPWriter) Length() int { +func (c *PCPClient) Length() int { return HeaderLength + - (w.tocCount() * TocLength) + - (w.Registry().InstanceCount() * InstanceLength) + - (w.Registry().InstanceDomainCount() * InstanceDomainLength) + - (w.Registry().MetricCount() * MetricLength) + - (w.Registry().ValuesCount() * ValueLength) + - (w.Registry().StringCount() * StringLength) + (c.tocCount() * TocLength) + + (c.Registry().InstanceCount() * InstanceLength) + + (c.Registry().InstanceDomainCount() * InstanceDomainLength) + + (c.Registry().MetricCount() * MetricLength) + + (c.Registry().ValuesCount() * ValueLength) + + (c.Registry().StringCount() * StringLength) } -func (w *PCPWriter) initializeInstanceAndInstanceDomainOffsets(instanceoffset, indomoffset int, stringsoffset *int) { - for _, indom := range w.r.instanceDomains { +func (c *PCPClient) initializeInstanceAndInstanceDomainOffsets(instanceoffset, indomoffset int, stringsoffset *int) { + for _, indom := range c.r.instanceDomains { indom.offset = indomoffset indom.instanceOffset = instanceoffset indomoffset += InstanceDomainLength @@ -187,7 +178,7 @@ func (w *PCPWriter) initializeInstanceAndInstanceDomainOffsets(instanceoffset, i } } -func (w *PCPWriter) initializeSingletonMetricOffsets(metric *PCPSingletonMetric, metricsoffset, valuesoffset, stringsoffset *int) { +func (c *PCPClient) initializeSingletonMetricOffsets(metric *PCPSingletonMetric, metricsoffset, valuesoffset, stringsoffset *int) { metric.descoffset = *metricsoffset *metricsoffset += MetricLength metric.valueoffset = *valuesoffset @@ -204,7 +195,7 @@ func (w *PCPWriter) initializeSingletonMetricOffsets(metric *PCPSingletonMetric, } } -func (w *PCPWriter) initializeInstanceMetricOffsets(metric *PCPInstanceMetric, metricsoffset, valuesoffset, stringsoffset *int) { +func (c *PCPClient) initializeInstanceMetricOffsets(metric *PCPInstanceMetric, metricsoffset, valuesoffset, stringsoffset *int) { metric.descoffset = *metricsoffset *metricsoffset += MetricLength @@ -224,283 +215,283 @@ func (w *PCPWriter) initializeInstanceMetricOffsets(metric *PCPInstanceMetric, m } } -func (w *PCPWriter) initializeOffsets() { - indomoffset := HeaderLength + TocLength*w.tocCount() - instanceoffset := indomoffset + InstanceDomainLength*w.r.InstanceDomainCount() - metricsoffset := instanceoffset + InstanceLength*w.r.InstanceCount() - valuesoffset := metricsoffset + MetricLength*w.r.MetricCount() - stringsoffset := valuesoffset + ValueLength*w.r.ValuesCount() +func (c *PCPClient) initializeOffsets() { + indomoffset := HeaderLength + TocLength*c.tocCount() + instanceoffset := indomoffset + InstanceDomainLength*c.r.InstanceDomainCount() + metricsoffset := instanceoffset + InstanceLength*c.r.InstanceCount() + valuesoffset := metricsoffset + MetricLength*c.r.MetricCount() + stringsoffset := valuesoffset + ValueLength*c.r.ValuesCount() - w.r.indomoffset = indomoffset - w.r.instanceoffset = instanceoffset - w.r.metricsoffset = metricsoffset - w.r.valuesoffset = valuesoffset - w.r.stringsoffset = stringsoffset + c.r.indomoffset = indomoffset + c.r.instanceoffset = instanceoffset + c.r.metricsoffset = metricsoffset + c.r.valuesoffset = valuesoffset + c.r.stringsoffset = stringsoffset - w.initializeInstanceAndInstanceDomainOffsets(instanceoffset, indomoffset, &stringsoffset) + c.initializeInstanceAndInstanceDomainOffsets(instanceoffset, indomoffset, &stringsoffset) - for _, metric := range w.r.metrics { + for _, metric := range c.r.metrics { switch m := metric.(type) { case *PCPSingletonMetric: - w.initializeSingletonMetricOffsets(m, &metricsoffset, &valuesoffset, &stringsoffset) + c.initializeSingletonMetricOffsets(m, &metricsoffset, &valuesoffset, &stringsoffset) case *PCPInstanceMetric: - w.initializeInstanceMetricOffsets(m, &metricsoffset, &valuesoffset, &stringsoffset) + c.initializeInstanceMetricOffsets(m, &metricsoffset, &valuesoffset, &stringsoffset) } } } -func (w *PCPWriter) writeHeaderBlock() (generation2offset int, generation int64) { +func (c *PCPClient) writeHeaderBlock() (generation2offset int, generation int64) { // tag - w.buffer.MustWriteString("MMV") - w.buffer.MustSetPos(w.buffer.Pos() + 1) // extra null byte is needed and \0 isn't a valid escape character in go + c.buffer.MustWriteString("MMV") + c.buffer.MustSetPos(c.buffer.Pos() + 1) // extra null byte is needed and \0 isn't a valid escape character in go // version - w.buffer.MustWriteUint32(1) + c.buffer.MustWriteUint32(1) // generation generation = time.Now().Unix() - w.buffer.MustWriteInt64(generation) + c.buffer.MustWriteInt64(generation) - generation2offset = w.buffer.Pos() + generation2offset = c.buffer.Pos() - w.buffer.MustWriteInt64(0) + c.buffer.MustWriteInt64(0) // tocCount - w.buffer.MustWriteInt32(int32(w.tocCount())) + c.buffer.MustWriteInt32(int32(c.tocCount())) // flag mask - w.buffer.MustWriteInt32(int32(w.flag)) + c.buffer.MustWriteInt32(int32(c.flag)) // process identifier - w.buffer.MustWriteInt32(int32(os.Getpid())) + c.buffer.MustWriteInt32(int32(os.Getpid())) // cluster identifier - w.buffer.MustWriteUint32(w.clusterID) + c.buffer.MustWriteUint32(c.clusterID) return } -func (w *PCPWriter) writeSingleToc(pos, identifier, count, offset int) { - w.buffer.MustSetPos(pos) - w.buffer.MustWriteInt32(int32(identifier)) - w.buffer.MustWriteInt32(int32(count)) - w.buffer.MustWriteUint64(uint64(offset)) +func (c *PCPClient) writeSingleToc(pos, identifier, count, offset int) { + c.buffer.MustSetPos(pos) + c.buffer.MustWriteInt32(int32(identifier)) + c.buffer.MustWriteInt32(int32(count)) + c.buffer.MustWriteUint64(uint64(offset)) } -func (w *PCPWriter) writeTocBlock() { +func (c *PCPClient) writeTocBlock() { tocpos := HeaderLength // instance domains toc - if w.Registry().InstanceDomainCount() > 0 { + if c.Registry().InstanceDomainCount() > 0 { // 1 is the identifier for instance domains - w.writeSingleToc(tocpos, 1, w.r.InstanceDomainCount(), w.r.indomoffset) + c.writeSingleToc(tocpos, 1, c.r.InstanceDomainCount(), c.r.indomoffset) tocpos += TocLength } // instances toc - if w.Registry().InstanceCount() > 0 { + if c.Registry().InstanceCount() > 0 { // 2 is the identifier for instances - w.writeSingleToc(tocpos, 2, w.r.InstanceCount(), w.r.instanceoffset) + c.writeSingleToc(tocpos, 2, c.r.InstanceCount(), c.r.instanceoffset) tocpos += TocLength } // metrics and values toc - metricsoffset, valuesoffset := w.r.metricsoffset, w.r.valuesoffset - if w.Registry().MetricCount() == 0 { + metricsoffset, valuesoffset := c.r.metricsoffset, c.r.valuesoffset + if c.Registry().MetricCount() == 0 { metricsoffset, valuesoffset = 0, 0 } // 3 is the identifier for metrics - w.writeSingleToc(tocpos, 3, w.r.MetricCount(), metricsoffset) + c.writeSingleToc(tocpos, 3, c.r.MetricCount(), metricsoffset) tocpos += TocLength // 4 is the identifier for values - w.writeSingleToc(tocpos, 4, w.r.ValuesCount(), valuesoffset) + c.writeSingleToc(tocpos, 4, c.r.ValuesCount(), valuesoffset) tocpos += TocLength // strings toc - if w.Registry().StringCount() > 0 { + if c.Registry().StringCount() > 0 { // 5 is the identifier for strings - w.writeSingleToc(tocpos, 5, w.r.StringCount(), w.r.stringsoffset) + c.writeSingleToc(tocpos, 5, c.r.StringCount(), c.r.stringsoffset) } } -func (w *PCPWriter) writeInstanceAndInstanceDomainBlock() { - for _, indom := range w.r.instanceDomains { - w.buffer.MustSetPos(indom.offset) - w.buffer.MustWriteUint32(indom.ID()) - w.buffer.MustWriteInt32(int32(indom.InstanceCount())) - w.buffer.MustWriteInt64(int64(indom.instanceOffset)) +func (c *PCPClient) writeInstanceAndInstanceDomainBlock() { + for _, indom := range c.r.instanceDomains { + c.buffer.MustSetPos(indom.offset) + c.buffer.MustWriteUint32(indom.ID()) + c.buffer.MustWriteInt32(int32(indom.InstanceCount())) + c.buffer.MustWriteInt64(int64(indom.instanceOffset)) so, lo := indom.shortDescription.offset, indom.longDescription.offset - w.buffer.MustWriteInt64(int64(so)) - w.buffer.MustWriteInt64(int64(lo)) + c.buffer.MustWriteInt64(int64(so)) + c.buffer.MustWriteInt64(int64(lo)) if so != 0 { - w.buffer.MustSetPos(so) - w.buffer.MustWriteString(indom.shortDescription.val) + c.buffer.MustSetPos(so) + c.buffer.MustWriteString(indom.shortDescription.val) } if lo != 0 { - w.buffer.MustSetPos(lo) - w.buffer.MustWriteString(indom.longDescription.val) + c.buffer.MustSetPos(lo) + c.buffer.MustWriteString(indom.longDescription.val) } for _, i := range indom.instances { - w.buffer.MustSetPos(i.offset) - w.buffer.MustWriteInt64(int64(indom.offset)) - w.buffer.MustWriteInt32(0) - w.buffer.MustWriteUint32(i.id) - w.buffer.MustWriteString(i.name) + c.buffer.MustSetPos(i.offset) + c.buffer.MustWriteInt64(int64(indom.offset)) + c.buffer.MustWriteInt32(0) + c.buffer.MustWriteUint32(i.id) + c.buffer.MustWriteString(i.name) } } } -func (w *PCPWriter) writeMetricDesc(m PCPMetric, pos int) { - w.buffer.MustSetPos(pos) +func (c *PCPClient) writeMetricDesc(m PCPMetric, pos int) { + c.buffer.MustSetPos(pos) - w.buffer.MustWriteString(m.Name()) - w.buffer.MustSetPos(pos + MaxMetricNameLength + 1) - w.buffer.MustWriteUint32(m.ID()) - w.buffer.MustWriteInt32(int32(m.Type())) - w.buffer.MustWriteInt32(int32(m.Semantics())) - w.buffer.MustWriteUint32(m.Unit().PMAPI()) + c.buffer.MustWriteString(m.Name()) + c.buffer.MustSetPos(pos + MaxMetricNameLength + 1) + c.buffer.MustWriteUint32(m.ID()) + c.buffer.MustWriteInt32(int32(m.Type())) + c.buffer.MustWriteInt32(int32(m.Semantics())) + c.buffer.MustWriteUint32(m.Unit().PMAPI()) if m.Indom() != nil { - w.buffer.MustWriteUint32(m.Indom().ID()) + c.buffer.MustWriteUint32(m.Indom().ID()) } else { - w.buffer.MustWriteInt32(-1) + c.buffer.MustWriteInt32(-1) } - w.buffer.MustWriteInt32(0) + c.buffer.MustWriteInt32(0) so, lo := m.ShortDescription().offset, m.LongDescription().offset - w.buffer.MustWriteInt64(int64(so)) - w.buffer.MustWriteInt64(int64(lo)) + c.buffer.MustWriteInt64(int64(so)) + c.buffer.MustWriteInt64(int64(lo)) if so != 0 { - w.buffer.MustSetPos(so) - w.buffer.MustWriteString(m.ShortDescription().val) + c.buffer.MustSetPos(so) + c.buffer.MustWriteString(m.ShortDescription().val) } if lo != 0 { - w.buffer.MustSetPos(lo) - w.buffer.MustWriteString(m.LongDescription().val) + c.buffer.MustSetPos(lo) + c.buffer.MustWriteString(m.LongDescription().val) } } -func (w *PCPWriter) writeInstance(t MetricType, val interface{}, valueoffset int) updateClosure { +func (c *PCPClient) writeInstance(t MetricType, val interface{}, valueoffset int) updateClosure { offset := valueoffset if t == StringType { - w.buffer.MustSetPos(offset) - w.buffer.MustWriteUint64(StringLength - 1) + c.buffer.MustSetPos(offset) + c.buffer.MustWriteUint64(StringLength - 1) offset = val.(*PCPString).offset - w.buffer.MustWriteUint64(uint64(offset)) + c.buffer.MustWriteUint64(uint64(offset)) } - update := newupdateClosure(offset, w.buffer, t) + update := newupdateClosure(offset, c.buffer, t) _ = update(val) - w.buffer.MustSetPos(valueoffset + MaxDataValueSize) + c.buffer.MustSetPos(valueoffset + MaxDataValueSize) return update } -func (w *PCPWriter) writeSingletonMetric(m *PCPSingletonMetric) { - w.writeMetricDesc(m, m.descoffset) - m.update = w.writeInstance(m.t, m.val, m.valueoffset) - w.buffer.MustWriteInt64(int64(m.descoffset)) - w.buffer.MustWriteInt64(0) +func (c *PCPClient) writeSingletonMetric(m *PCPSingletonMetric) { + c.writeMetricDesc(m, m.descoffset) + m.update = c.writeInstance(m.t, m.val, m.valueoffset) + c.buffer.MustWriteInt64(int64(m.descoffset)) + c.buffer.MustWriteInt64(0) } -func (w *PCPWriter) writeInstanceMetric(m *PCPInstanceMetric) { - w.writeMetricDesc(m, m.descoffset) +func (c *PCPClient) writeInstanceMetric(m *PCPInstanceMetric) { + c.writeMetricDesc(m, m.descoffset) for name, i := range m.indom.instances { ival := m.vals[name] - ival.update = w.writeInstance(m.t, ival.val, ival.offset) - w.buffer.MustWriteInt64(int64(m.descoffset)) - w.buffer.MustWriteInt64(int64(i.offset)) + ival.update = c.writeInstance(m.t, ival.val, ival.offset) + c.buffer.MustWriteInt64(int64(m.descoffset)) + c.buffer.MustWriteInt64(int64(i.offset)) } } -func (w *PCPWriter) writeMetricsAndValuesBlock() { - for _, metric := range w.r.metrics { +func (c *PCPClient) writeMetricsAndValuesBlock() { + for _, metric := range c.r.metrics { switch metric.(type) { case *PCPSingletonMetric: - w.writeSingletonMetric(metric.(*PCPSingletonMetric)) + c.writeSingletonMetric(metric.(*PCPSingletonMetric)) case *PCPInstanceMetric: - w.writeInstanceMetric(metric.(*PCPInstanceMetric)) + c.writeInstanceMetric(metric.(*PCPInstanceMetric)) } } } // fillData will fill the Buffer with the mmv file // data as long as something doesn't go wrong -func (w *PCPWriter) fillData() error { - generation2offset, generation := w.writeHeaderBlock() - w.writeTocBlock() - w.writeInstanceAndInstanceDomainBlock() - w.writeMetricsAndValuesBlock() +func (c *PCPClient) fillData() error { + generation2offset, generation := c.writeHeaderBlock() + c.writeTocBlock() + c.writeInstanceAndInstanceDomainBlock() + c.writeMetricsAndValuesBlock() - w.buffer.MustSetPos(generation2offset) - w.buffer.MustWriteUint64(uint64(generation)) + c.buffer.MustSetPos(generation2offset) + c.buffer.MustWriteUint64(uint64(generation)) return nil } // Start dumps existing registry data -func (w *PCPWriter) Start() error { - w.Lock() - defer w.Unlock() +func (c *PCPClient) Start() error { + c.Lock() + defer c.Unlock() - l := w.Length() + l := c.Length() writerlog.WithField("length", l).Info("initializing writing the MMV file") - w.initializeOffsets() + c.initializeOffsets() writerlog.Info("initialized offsets for all written types") - buffer, err := bytebuffer.NewMemoryMappedBuffer(w.loc, l) + buffer, err := bytebuffer.NewMemoryMappedBuffer(c.loc, l) if err != nil { writerlog.WithField("error", err).Error("cannot create MemoryMappedBuffer") return err } - w.buffer = buffer + c.buffer = buffer writerlog.Info("created MemoryMappedBuffer") - err = w.fillData() + err = c.fillData() if err != nil { writerlog.WithField("error", err).Error("cannot fill MMV data") return err } writerlog.Info("written data to MMV file") - w.r.mapped = true + c.r.mapped = true return nil } // MustStart is a start that panics -func (w *PCPWriter) MustStart() { - if err := w.Start(); err != nil { +func (c *PCPClient) MustStart() { + if err := c.Start(); err != nil { panic(err) } } // Stop removes existing mapping and cleans up -func (w *PCPWriter) Stop() error { - w.Lock() - defer w.Unlock() +func (c *PCPClient) Stop() error { + c.Lock() + defer c.Unlock() - if !w.r.mapped { + if !c.r.mapped { return errors.New("trying to stop an already stopped mapping") } writerlog.Info("stopping the writer") - w.r.mapped = false + c.r.mapped = false - err := w.buffer.(*bytebuffer.MemoryMappedBuffer).Unmap(EraseFileOnStop) - w.buffer = nil + err := c.buffer.(*bytebuffer.MemoryMappedBuffer).Unmap(EraseFileOnStop) + c.buffer = nil if err != nil { writerlog.WithField("error", err).Error("error unmapping MemoryMappedBuffer") return err @@ -512,42 +503,42 @@ func (w *PCPWriter) Stop() error { } // MustStop is a stop that panics -func (w *PCPWriter) MustStop() { - if err := w.Stop(); err != nil { +func (c *PCPClient) MustStop() { + if err := c.Stop(); err != nil { panic(err) } } // Register is simply a shorthand for Registry().AddMetric -func (w *PCPWriter) Register(m Metric) error { return w.Registry().AddMetric(m) } +func (c *PCPClient) Register(m Metric) error { return c.Registry().AddMetric(m) } // MustRegister is simply a Register that can panic -func (w *PCPWriter) MustRegister(m Metric) { - if err := w.Register(m); err != nil { +func (c *PCPClient) MustRegister(m Metric) { + if err := c.Register(m); err != nil { panic(err) } } // RegisterIndom is simply a shorthand for Registry().AddInstanceDomain -func (w *PCPWriter) RegisterIndom(indom InstanceDomain) error { - return w.Registry().AddInstanceDomain(indom) +func (c *PCPClient) RegisterIndom(indom InstanceDomain) error { + return c.Registry().AddInstanceDomain(indom) } // MustRegisterIndom is simply a RegisterIndom that can panic -func (w *PCPWriter) MustRegisterIndom(indom InstanceDomain) { - if err := w.RegisterIndom(indom); err != nil { +func (c *PCPClient) MustRegisterIndom(indom InstanceDomain) { + if err := c.RegisterIndom(indom); err != nil { panic(err) } } // RegisterString is simply a shorthand for Registry().AddMetricByString -func (w *PCPWriter) RegisterString(str string, val interface{}, s MetricSemantics, t MetricType, u MetricUnit) (Metric, error) { - return w.Registry().AddMetricByString(str, val, s, t, u) +func (c *PCPClient) RegisterString(str string, val interface{}, s MetricSemantics, t MetricType, u MetricUnit) (Metric, error) { + return c.Registry().AddMetricByString(str, val, s, t, u) } // MustRegisterString is simply a RegisterString that panics -func (w *PCPWriter) MustRegisterString(str string, val interface{}, s MetricSemantics, t MetricType, u MetricUnit) Metric { - if m, err := w.RegisterString(str, val, s, t, u); err != nil { +func (c *PCPClient) MustRegisterString(str string, val interface{}, s MetricSemantics, t MetricType, u MetricUnit) Metric { + if m, err := c.RegisterString(str, val, s, t, u); err != nil { panic(err) } else { return m diff --git a/writer_test.go b/client_test.go similarity index 73% rename from writer_test.go rename to client_test.go index 39cfe6a..535f30a 100644 --- a/writer_test.go +++ b/client_test.go @@ -35,18 +35,18 @@ func TestMmvFileLocation(t *testing.T) { } func TestTocCountAndLength(t *testing.T) { - w, err := NewPCPWriter("test", ProcessFlag) + c, err := NewPCPClient("test", ProcessFlag) if err != nil { t.Errorf("cannot create writer, error: %v", err) } - if w.tocCount() != 2 { - t.Errorf("expected tocCount to be 2, got %v", w.tocCount()) + if c.tocCount() != 2 { + t.Errorf("expected tocCount to be 2, got %v", c.tocCount()) } expectedLength := HeaderLength + 2*TocLength - if w.Length() != expectedLength { - t.Errorf("expected Length to be %v, got %v", expectedLength, w.Length()) + if c.Length() != expectedLength { + t.Errorf("expected Length to be %v, got %v", expectedLength, c.Length()) } m, err := NewPCPSingletonMetric(10, "test", Int32Type, CounterSemantics, OneUnit, "test", "") @@ -54,18 +54,18 @@ func TestTocCountAndLength(t *testing.T) { t.Error("Cannot create a metric") } - w.MustRegister(m) - if w.tocCount() != 3 { - t.Errorf("expected tocCount to be 3, got %v", w.tocCount()) + c.MustRegister(m) + if c.tocCount() != 3 { + t.Errorf("expected tocCount to be 3, got %v", c.tocCount()) } expectedLength = HeaderLength + 3*TocLength + 1*MetricLength + 1*ValueLength + 1*StringLength - if w.Length() != expectedLength { - t.Errorf("expected Length to be %v, got %v", expectedLength, w.Length()) + if c.Length() != expectedLength { + t.Errorf("expected Length to be %v, got %v", expectedLength, c.Length()) } indom, _ := NewPCPInstanceDomain("testindom", []string{"test"}, "", "") - w.MustRegisterIndom(indom) + c.MustRegisterIndom(indom) m2, err := NewPCPInstanceMetric( Instances{ @@ -77,36 +77,36 @@ func TestTocCountAndLength(t *testing.T) { t.Error("Cannot create a metric") } - err = w.Register(m2) + err = c.Register(m2) if err != nil { t.Error("Cannot register m2") } - if w.tocCount() != 5 { - t.Errorf("expected tocCount to be 5, got %v", w.tocCount()) + if c.tocCount() != 5 { + t.Errorf("expected tocCount to be 5, got %v", c.tocCount()) } } func TestMapping(t *testing.T) { - w, err := NewPCPWriter("test", ProcessFlag) - _, err = w.RegisterString("test.1", 2, CounterSemantics, Int32Type, OneUnit) + c, err := NewPCPClient("test", ProcessFlag) + _, err = c.RegisterString("test.1", 2, CounterSemantics, Int32Type, OneUnit) if err != nil { t.Error("Cannot Register") } - w.MustStart() + c.MustStart() loc, _ := mmvFileLocation("test") if _, err = os.Stat(loc); err != nil { t.Error("expected a MMV file to be created on startup") } - _, err = w.RegisterString("test.2", 2, CounterSemantics, Int32Type, OneUnit) + _, err = c.RegisterString("test.2", 2, CounterSemantics, Int32Type, OneUnit) if err == nil { t.Error("expected registration to fail when a mapping is active") } EraseFileOnStop = true - err = w.Stop() + err = c.Stop() if err != nil { t.Error("Cannot stop a mapping") } diff --git a/examples/acme/main.go b/examples/acme/main.go index cfa3faf..1cde1cf 100644 --- a/examples/acme/main.go +++ b/examples/acme/main.go @@ -58,17 +58,17 @@ func main() { panic(err) } - writer, err := speed.NewPCPWriter("acme", speed.ProcessFlag) + client, err := speed.NewPCPClient("acme", speed.ProcessFlag) if err != nil { panic(err) } - writer.MustRegisterIndom(indom) - writer.MustRegister(countmetric) - writer.MustRegister(timemetric) + client.MustRegisterIndom(indom) + client.MustRegister(countmetric) + client.MustRegister(timemetric) - writer.MustStart() - defer writer.MustStop() + client.MustStart() + defer client.MustStop() time.Sleep(time.Second * 5) err = countmetric.SetInstance("Anvils", 42) diff --git a/examples/http_counter/server.go b/examples/http_counter/server.go index 69abad8..5fe7213 100644 --- a/examples/http_counter/server.go +++ b/examples/http_counter/server.go @@ -27,15 +27,15 @@ func main() { panic(err) } - writer, err := speed.NewPCPWriter("example", speed.ProcessFlag) + client, err := speed.NewPCPClient("example", speed.ProcessFlag) if err != nil { panic(err) } - writer.MustRegister(metric) + client.MustRegister(metric) - writer.MustStart() - defer writer.MustStop() + client.MustStart() + defer client.MustStop() http.HandleFunc("/increment", handleIncrement) go func() { diff --git a/examples/instance_string/main.go b/examples/instance_string/main.go index 937a25b..352d05e 100644 --- a/examples/instance_string/main.go +++ b/examples/instance_string/main.go @@ -12,12 +12,12 @@ var timelimit = flag.Int("time", 60, "number of seconds to run for") func main() { flag.Parse() - w, err := speed.NewPCPWriter("strings", speed.ProcessFlag) + c, err := speed.NewPCPClient("strings", speed.ProcessFlag) if err != nil { panic(err) } - m, err := w.RegisterString("language[go, javascript, php].users", speed.Instances{ + m, err := c.RegisterString("language[go, javascript, php].users", speed.Instances{ "go": 1, "javascript": 100, "php": 10, @@ -26,8 +26,8 @@ func main() { panic(err) } - w.MustStart() - defer w.MustStop() + c.MustStart() + defer c.MustStop() metric := m.(speed.InstanceMetric) for i := 0; i < *timelimit; i++ { diff --git a/examples/simple/main.go b/examples/simple/main.go index 8a25d0d..9e383d0 100644 --- a/examples/simple/main.go +++ b/examples/simple/main.go @@ -21,15 +21,15 @@ func main() { panic(err) } - writer, err := speed.NewPCPWriter("simple", speed.ProcessFlag) + client, err := speed.NewPCPClient("simple", speed.ProcessFlag) if err != nil { panic(err) } - writer.MustRegister(metric) + client.MustRegister(metric) - writer.MustStart() - defer writer.MustStop() + client.MustStart() + defer client.MustStop() fmt.Println("The metric is currently mapped as mmv.simple.simple.counter, to stop the mapping, press enter") _, _ = os.Stdin.Read(make([]byte, 1)) diff --git a/examples/simple_string_metric/main.go b/examples/simple_string_metric/main.go index 46e9406..ffa51ed 100644 --- a/examples/simple_string_metric/main.go +++ b/examples/simple_string_metric/main.go @@ -12,7 +12,7 @@ var timelimit = flag.Int("time", 60, "number of seconds to run for") func main() { flag.Parse() - w, err := speed.NewPCPWriter("stringtest", speed.ProcessFlag) + c, err := speed.NewPCPClient("stringtest", speed.ProcessFlag) if err != nil { panic(err) } @@ -26,13 +26,13 @@ func main() { "Red Hood", } - m, err := w.RegisterString("bat.names", names[0], speed.InstantSemantics, speed.StringType, speed.OneUnit) + m, err := c.RegisterString("bat.names", names[0], speed.InstantSemantics, speed.StringType, speed.OneUnit) if err != nil { panic(err) } - w.MustStart() - defer w.MustStop() + c.MustStart() + defer c.MustStop() metric := m.(speed.SingletonMetric) for i := 0; i < *timelimit; i++ { diff --git a/examples/singleton_counter/main.go b/examples/singleton_counter/main.go index b922936..d93339a 100644 --- a/examples/singleton_counter/main.go +++ b/examples/singleton_counter/main.go @@ -28,18 +28,18 @@ func main() { panic(err) } - writer, err := speed.NewPCPWriter("singletoncounter", speed.ProcessFlag) + client, err := speed.NewPCPClient("singletoncounter", speed.ProcessFlag) if err != nil { panic(err) } - err = writer.Register(metric) + err = client.Register(metric) if err != nil { panic(err) } - writer.MustStart() - defer writer.MustStop() + client.MustStart() + defer client.MustStop() fmt.Println("The metric should be visible as mmv.singletoncounter.counter") for i := 0; i < *timelimit; i++ { diff --git a/examples/singleton_string/main.go b/examples/singleton_string/main.go index 95e2dba..faacc5e 100644 --- a/examples/singleton_string/main.go +++ b/examples/singleton_string/main.go @@ -13,18 +13,18 @@ var timelimit = flag.Int("time", 60, "number of seconds to run for") func main() { flag.Parse() - w, err := speed.NewPCPWriter("strings", speed.ProcessFlag) + c, err := speed.NewPCPClient("strings", speed.ProcessFlag) if err != nil { panic(err) } - m, err := w.RegisterString("simple.counter", 10, speed.CounterSemantics, speed.Int32Type, speed.OneUnit) + m, err := c.RegisterString("simple.counter", 10, speed.CounterSemantics, speed.Int32Type, speed.OneUnit) if err != nil { panic(err) } - w.MustStart() - defer w.MustStop() + c.MustStart() + defer c.MustStop() metric := m.(speed.SingletonMetric) for i := 0; i < *timelimit; i++ {