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):
