def test_update_metrics(self): # prepare test meta_dict = { "aggregator": bg_accessor.Aggregator.last, "retention": bg_accessor.Retention.from_string("60*1s:60*60s"), "carbon_xfilesfactor": 0.3, } metadata = bg_accessor.MetricMetadata(**meta_dict) metric_name = "a.b.c.d.e.f" self.accessor.create_metric( self.accessor.make_metric(metric_name, metadata)) metric = self.accessor.get_metric(metric_name) for k, v in meta_dict.iteritems(): self.assertEqual(v, getattr(metric.metadata, k)) # test updated_meta_dict = { "aggregator": bg_accessor.Aggregator.maximum, "retention": bg_accessor.Retention.from_string("30*1s:120*30s"), "carbon_xfilesfactor": 0.5, } updated_metadata = bg_accessor.MetricMetadata(**updated_meta_dict) # Setting a known metric name should work self.accessor.update_metric(metric_name, updated_metadata) updated_metric = self.accessor.get_metric(metric_name) for k, v in updated_meta_dict.iteritems(): self.assertEqual(v, getattr(updated_metric.metadata, k)) # Setting an unknown metric name should fail self.assertRaises( bg_cassandra.InvalidArgumentError, self.accessor.update_metric, "fake.metric.name", updated_metadata)
def test_run(self): self.accessor.drop_all_metrics() cmd = command_list.CommandList() parser = argparse.ArgumentParser() bg_utils.add_argparse_arguments(parser) cmd.add_arguments(parser) name = 'foo.bar' metadata = bg_accessor.MetricMetadata( retention=bg_accessor.Retention.from_string('1440*60s')) self.accessor.create_metric(self.make_metric(name, metadata)) opts = parser.parse_args(['foo.*']) cmd.run(self.accessor, opts) metrics = command_list.list_metrics(self.accessor, opts.glob, opts.graphite) self.assertEqual(name, list(metrics)[0].name) opts = parser.parse_args(['--graphite', 'foo.{bar}']) metrics = command_list.list_metrics(self.accessor, opts.glob, opts.graphite) self.assertEqual(name, list(metrics)[0].name)
def create(self, metric_name, retentions, xfilesfactor, aggregation_method): metadata = accessor.MetricMetadata( aggregator=accessor.Aggregator.from_carbon_name(aggregation_method), retention=accessor.Retention.from_carbon(retentions), carbon_xfilesfactor=xfilesfactor, ) metric = self.cache.make_metric(metric_name, metadata) self.cache.cache_set(metric_name, metric) self._createAsync(metric)
def setUp(self): """Set up a Downsampler, aggregating with the sum and average function.""" capacity_precisions = (self.CAPACITY, self.PRECISION, self.CAPACITY, self.PRECISION**2) retention_string = "%d*%ds:%d*%ds" % (capacity_precisions) retention = bg_accessor.Retention.from_string(retention_string) self.stage_0 = retention.stages[0] self.stage_1 = retention.stages[1] uid = uuid.uuid4() metric_metadata = bg_accessor.MetricMetadata( aggregator=bg_accessor.Aggregator.total, retention=retention) self.metric_sum = bg_accessor.Metric(self.METRIC_NAME_SUM, uid, metric_metadata) uid = uuid.uuid4() metric_metadata = bg_accessor.MetricMetadata( aggregator=bg_accessor.Aggregator.average, retention=retention) self.metric_avg = bg_accessor.Metric(self.METRIC_NAME_AVG, uid, metric_metadata) self.ds = bg_ds.Downsampler(self.CAPACITY)
def test_run(self): name = 'foo.bar' metadata = bg_accessor.MetricMetadata( retention=bg_accessor.Retention.from_string('1440*60s')) self.accessor.create_metric(self.make_metric(name, metadata)) cmd = command_read.CommandRead() parser = argparse.ArgumentParser() bg_utils.add_argparse_arguments(parser) cmd.add_arguments(parser) opts = parser.parse_args([name]) cmd.run(self.accessor, opts)
def test_update_metrics(self): if isinstance(self.accessor, bg_elasticsearch._ElasticSearchAccessor): # TODO (t.chataigner) Remove once update_metric is implemented. self.skipTest( "update_metric is not implemented for _ElasticSearchAccessor.") # prepare test meta_dict = { "aggregator": bg_accessor.Aggregator.last, "retention": bg_accessor.Retention.from_string("60*1s:60*60s"), "carbon_xfilesfactor": 0.3, } metadata = bg_accessor.MetricMetadata(**meta_dict) metric_name = "a.b.c.d.e.f" self.accessor.create_metric( self.accessor.make_metric(metric_name, metadata)) self.flush() metric = self.accessor.get_metric(metric_name) for k, v in meta_dict.items(): self.assertEqual(v, getattr(metric.metadata, k)) # test updated_meta_dict = { "aggregator": bg_accessor.Aggregator.maximum, "retention": bg_accessor.Retention.from_string("30*1s:120*30s"), "carbon_xfilesfactor": 0.5, } updated_metadata = bg_accessor.MetricMetadata(**updated_meta_dict) # Setting a known metric name should work self.accessor.update_metric(metric_name, updated_metadata) updated_metric = self.accessor.get_metric(metric_name) for k, v in updated_meta_dict.items(): self.assertEqual(v, getattr(updated_metric.metadata, k)) # Setting an unknown metric name should fail self.assertRaises(bg_cassandra.InvalidArgumentError, self.accessor.update_metric, "fake.metric.name", updated_metadata)
def make_metric(name, metadata=None, accessor=None, **kwargs): """Create a bg_accessor.Metric with specified metadata.""" encoded_name = bg_accessor.encode_metric_name(name) retention = kwargs.get("retention") if isinstance(retention, basestring): kwargs["retention"] = bg_accessor.Retention.from_string(retention) if metadata: assert isinstance(metadata, bg_accessor.MetricMetadata) assert not kwargs else: metadata = bg_accessor.MetricMetadata(**kwargs) if not accessor: uid = uuid.uuid5(_UUID_NAMESPACE, encoded_name) return bg_accessor.Metric(name, uid, metadata) else: return accessor.make_metric(name, metadata)
def setUp(self): """Set up a delayed wrier.""" super(TestDelayedWriter, self).setUp() stages = (self.DURATION, self.PRECISION, self.DURATION, self.PRECISION * 100) retention_string = "%d*%ds:%d*%ds" % (stages) retention = bg_accessor.Retention.from_string(retention_string) self.stage_0 = retention.stages[0] self.stage_1 = retention.stages[1] metadata = bg_accessor.MetricMetadata( aggregator=bg_accessor.Aggregator.average, retention=retention) self.metric = self.make_metric(self.METRIC_NAME, metadata=metadata) self.accessor.create_metric(self.metric) self.dw = bg_dw.DelayedWriter(self.accessor, period_ms=self.WRITER_PERIOD)
def _read_metadata(metric_name, path): info = whisper.info(path) if not info: return None retentions = bg_accessor.Retention([ bg_accessor.Stage(precision=a["secondsPerPoint"], points=a["points"]) for a in info["archives"] ]) aggregator = bg_accessor.Aggregator.from_carbon_name( info["aggregationMethod"]) return bg_accessor.MetricMetadata( aggregator=aggregator, retention=retentions, carbon_xfilesfactor=info["xFilesFactor"], )
def run(self, accessor, opts): """Run the command.""" accessor.connect() metric = accessor.get_metric(opts.metric) if not metric: print("Metric '%s' was not found and will be created" % opts.metric) metadata = bg_accessor.MetricMetadata( aggregator=bg_accessor.Aggregator.from_config_name( opts.aggregator), retention=bg_accessor.Retention.from_string(opts.retention), carbon_xfilesfactor=opts.x_files_factor, ) metric = accessor.make_metric(opts.metric, metadata) accessor.create_metric(metric) timestamp = int(time.mktime(opts.timestamp.timetuple())) points = [(timestamp, float(opts.value))] * opts.count accessor.insert_points_async(metric, points)
def test_run(self): self.accessor.drop_all_metrics() cmd = command_delete.CommandDelete() parser = argparse.ArgumentParser() bg_utils.add_argparse_arguments(parser) cmd.add_arguments(parser) name = 'foo.bar' metadata = bg_accessor.MetricMetadata( retention=bg_accessor.Retention.from_string('1440*60s')) self.accessor.create_metric(self.make_metric(name, metadata)) opts = parser.parse_args(['foo', '--recursive', '--dry-run']) cmd.run(self.accessor, opts) self.assertIn(name, self.accessor.glob_metric_names('*.*')) opts = parser.parse_args(['foo', '--recursive']) cmd.run(self.accessor, opts) self.assertNotIn(name, self.accessor.glob_metric_names('*.*'))
def __get_metadata(self): self.__refresh_metric() if self._metric is not None: return self._metric.metadata else: return bg_accessor.MetricMetadata()
def _gen_metric(accessor): digits = "".join( [random.choice(string.digits + string.letters) for i in xrange(10)]) retention = bg_accessor.Retention.from_string("86400*1s:10080*60s") metadata = bg_accessor.MetricMetadata(retention=retention) return accessor.make_metric(digits, metadata)
def _gen_metric(accessor): retention = bg_accessor.Retention.from_string("86400*1s:10080*60s") metadata = bg_accessor.MetricMetadata(retention=retention) return accessor.make_metric(_random_name(10), metadata)
# # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import unittest from mock import Mock from biggraphite import accessor as bg_accessor from biggraphite.drivers import hybrid DEFAULT_METRIC_NAME = "foo.bar" DEFAULT_METADATA = bg_accessor.MetricMetadata() DEFAULT_METRIC = bg_accessor.Metric(DEFAULT_METRIC_NAME, "id", DEFAULT_METADATA) DEFAULT_GLOB = "foo.bar.**" class TestHybridAccessor(unittest.TestCase): def setUp(self): self._metadata_accessor = Mock() self._data_accessor = Mock() self._accessor = hybrid.HybridAccessor("test_hybrid", self._metadata_accessor, self._data_accessor) def test_connect_should_be_called_on_both_accessors(self):