def test_run(self):
self.accessor.drop_all_metrics()
cmd = command_list.CommandList()
parser = argparse.ArgumentParser()
bg_settings.add_argparse_arguments(parser)
cmd.add_arguments(parser)
name = "foo.bar"
metadata = bg_metric.MetricMetadata(
retention=bg_metric.Retention.from_string("1440*60s"))
self.accessor.create_metric(bg_test_utils.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 make_metric(name, metadata=None, **kwargs):
"""Create a bg_accessor.Metric with specified metadata."""
encoded_name = bg_metric.encode_metric_name(name)
retention = kwargs.get("retention")
if isinstance(retention, str):
kwargs["retention"] = bg_metric.Retention.from_string(retention)
if metadata:
assert isinstance(metadata, bg_metric.MetricMetadata)
assert not kwargs
else:
metadata = bg_metric.MetricMetadata(**kwargs)
return bg_metric.make_metric(encoded_name, metadata)
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_metric.Aggregator.last,
"retention": bg_metric.Retention.from_string("60*1s:60*60s"),
"carbon_xfilesfactor": 0.3,
}
metadata = bg_metric.MetricMetadata(**meta_dict)
metric_name = "a.b.c.d.e.f"
self.accessor.create_metric(
bg_test_utils.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_metric.Aggregator.maximum,
"retention": bg_metric.Retention.from_string("30*1s:120*30s"),
"carbon_xfilesfactor": 0.5,
}
updated_metadata = bg_metric.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 post(self, name):
"""Update a metric."""
if not context.accessor.has_metric(name):
return "Unknown metric: '%s'" % name, 404
payload = request.json
metadata = bg_metric.MetricMetadata(
aggregator=bg_metric.Aggregator.from_config_name(
payload["aggregator"]),
retention=bg_metric.Retention.from_string(payload["retention"]),
carbon_xfilesfactor=payload["carbon_xfilesfactor"],
)
context.accessor.update_metric(name, metadata)
return "", 204
def test_run(self):
name = "foo.bar"
metadata = bg_metric.MetricMetadata(
retention=bg_metric.Retention.from_string("1440*60s")
)
self.accessor.create_metric(bg_test_utils.make_metric(name, metadata))
cmd = command_read.CommandRead()
parser = argparse.ArgumentParser()
bg_settings.add_argparse_arguments(parser)
cmd.add_arguments(parser)
opts = parser.parse_args([name])
cmd.run(self.accessor, opts)
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_metric.Retention.from_string(retention_string)
self.stage_0 = retention.stages[0]
self.stage_1 = retention.stages[1]
uid = uuid.uuid4()
metric_metadata = bg_metric.MetricMetadata(
aggregator=bg_metric.Aggregator.total, retention=retention)
self.metric_sum = bg_metric.Metric(self.METRIC_NAME_SUM, uid,
metric_metadata)
uid = uuid.uuid4()
metric_metadata = bg_metric.MetricMetadata(
aggregator=bg_metric.Aggregator.average, retention=retention)
self.metric_avg = bg_metric.Metric(self.METRIC_NAME_AVG, uid,
metric_metadata)
self.ds = bg_ds.Downsampler(self.CAPACITY)
def _read_metadata(metric_name, path):
info = whisper.info(path)
if not info:
return None
retentions = bg_metric.Retention([
bg_metric.Stage(precision=a["secondsPerPoint"], points=a["points"])
for a in info["archives"]
])
aggregator = bg_metric.Aggregator.from_carbon_name(
info["aggregationMethod"])
return bg_metric.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_metric.MetricMetadata(
aggregator=bg_metric.Aggregator.from_config_name(
opts.aggregator),
retention=bg_metric.Retention.from_string(opts.retention),
carbon_xfilesfactor=opts.x_files_factor,
)
metric = bg_metric.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_setting.add_argparse_arguments(parser)
cmd.add_arguments(parser)
name = "foo.bar"
metadata = bg_metric.MetricMetadata(
retention=bg_metric.Retention.from_string("1440*60s"))
self.accessor.create_metric(bg_test_utils.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_metric.MetricMetadata()
def _gen_metric(accessor):
retention = bg_metric.Retention.from_string("86400*1s:10080*60s")
metadata = bg_metric.MetricMetadata(retention=retention)
return bg_metric.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 metric as bg_metric
from biggraphite.drivers import hybrid
DEFAULT_METRIC_NAME = "foo.bar"
DEFAULT_METADATA = bg_metric.MetricMetadata()
DEFAULT_METRIC = bg_metric.Metric(DEFAULT_METRIC_NAME, "id", DEFAULT_METADATA)
DEFAULT_GLOB = "foo.bar.**"
class TestHybridAccessor(unittest.TestCase):
def setUp(self):
self._metadata_accessor = Mock()
self._metadata_accessor.TYPE = 'mock'
self._data_accessor = Mock()
self._data_accessor.TYPE = 'mock'
self._accessor = hybrid.HybridAccessor("test_hybrid",
self._metadata_accessor,
self._data_accessor)
