def setUp(self):
"""Setup the test."""
yield super(TestStats, self).setUp()
self.obj_factory.make_user(999, u'test user999', u'', 2 ** 20)
self.metrics = FakeMetrics()
MetricsConnector.register_metrics("root", instance=self.metrics)
self.service.stats_worker.stop()
def setUp(self):
"""Setup the test."""
yield super(TestStats, self).setUp()
self.obj_factory.make_user(999, u'test user999', u'', 2**20)
self.metrics = FakeMetrics()
MetricsConnector.register_metrics("root", instance=self.metrics)
self.service.stats_worker.stop()
def tearDown(self):
"""Tear down test."""
MetricsConnector.unregister_metrics()
try:
self.mocker.verify()
finally:
yield super(TestDelivery, self).tearDown()
self.mocker.restore()
def tearDown(self):
"""Tear down test."""
MetricsConnector.unregister_metrics()
try:
self.mocker.verify()
finally:
yield super(TestDelivery, self).tearDown()
self.mocker.restore()
def test_register_mock_metrics(self):
"""Test that we can register a mock for testing."""
mocker = Mocker()
mock_metrics = mocker.mock(ExtendedMetrics)
mock_metrics.meter("abc", 123)
MetricsConnector.register_metrics("x", instance=mock_metrics)
with mocker:
MetricsConnector.get_metrics("x").meter("abc", 123)
def test_register_mock_metrics(self):
"""Test that we can register a mock for testing."""
mocker = Mocker()
mock_metrics = mocker.mock(ExtendedMetrics)
mock_metrics.meter("abc", 123)
MetricsConnector.register_metrics("x", instance=mock_metrics)
with mocker:
MetricsConnector.get_metrics("x").meter("abc", 123)
def setUp(self):
yield super(SSLProxyServiceTest, self).setUp()
self.configure_logging()
self._old_heartbeat_interval = config.ssl_proxy.heartbeat_interval
self.metrics = MetricReceiver()
namespace = config.ssl_proxy.metrics_namespace
instance = MetricsConnector.new_txmetrics(connection=self.metrics,
namespace=namespace)
MetricsConnector.register_metrics("ssl-proxy", namespace, instance)
config.ssl_proxy.heartbeat_interval = self.ssl_proxy_heartbeat_interval
def setUp(self):
yield super(SSLProxyServiceTest, self).setUp()
self.configure_logging()
self._old_heartbeat_interval = config.ssl_proxy.heartbeat_interval
self.metrics = MetricReceiver()
namespace = config.ssl_proxy.metrics_namespace
instance = MetricsConnector.new_txmetrics(connection=self.metrics,
namespace=namespace)
MetricsConnector.register_metrics("ssl-proxy", namespace, instance)
config.ssl_proxy.heartbeat_interval = self.ssl_proxy_heartbeat_interval
def setUp(self):
yield super(SSLProxyServiceTest, self).setUp()
self.configure_logging()
self.metrics = MetricReceiver()
namespace = settings.ssl_proxy.METRICS_NAMESPACE
instance = MetricsConnector.new_txmetrics(connection=self.metrics,
namespace=namespace)
MetricsConnector.register_metrics("ssl-proxy", namespace, instance)
self.patch(settings.ssl_proxy, 'HEARTBEAT_INTERVAL',
self.ssl_proxy_heartbeat_interval)
def startFactory(self):
"""Start any other stuff we need."""
logger.info("listening on %d -> %s:%d", self.listen_port, self.host,
self.port)
try:
self.metrics = MetricsConnector.get_metrics("ssl-proxy")
except ComponentLookupError:
namespace = config.ssl_proxy.metrics_namespace
MetricsConnector.register_metrics("ssl-proxy", namespace)
self.metrics = MetricsConnector.get_metrics("ssl-proxy")
self.metrics.meter("server_start", 1)
def startFactory(self):
"""Start any other stuff we need."""
logger.info("listening on %d -> %s:%d",
self.listen_port, self.host, self.port)
try:
self.metrics = MetricsConnector.get_metrics("ssl-proxy")
except ComponentLookupError:
namespace = config.ssl_proxy.metrics_namespace
MetricsConnector.register_metrics("ssl-proxy", namespace)
self.metrics = MetricsConnector.get_metrics("ssl-proxy")
self.metrics.meter("server_start", 1)
def test_configured_statsd(self):
"""Test configuring of Metrics using supplied configuration."""
self.patch(settings, 'STATSD_SERVERS', "localhost:8125")
metrics = MetricsConnector.new_metrics()
self.failIf(metrics.connection is None)
self.failIf(metrics.connection.socket is None)
self.metrics = MetricsConnector.new_txmetrics()
yield self.metrics.connection.resolve_later
self.failIf(self.metrics.connection is None)
self.failIf(self.metrics.connection.transport is None)
self.assertEqual(self.metrics.connection.port, 8125)
def test_configured_statsd(self):
"""Test configuring of Metrics using supplied configuration."""
self.patch(config.statsd, 'servers', "localhost:8125")
metrics = MetricsConnector.new_metrics()
self.failIf(metrics.connection is None)
self.failIf(metrics.connection.socket is None)
self.metrics = MetricsConnector.new_txmetrics()
yield self.metrics.connection.resolve_later
self.failIf(self.metrics.connection is None)
self.failIf(self.metrics.connection.transport is None)
self.assertEqual(self.metrics.connection.port, 8125)
def setUp(self):
"""Set up."""
class Helper(object):
"""Fake object with a controllable call."""
def __init__(self):
self.call_count = 1
self.calls = []
self.ri = None
def call(self, func):
"""Call function when counter is 0, then stop running."""
self.call_count -= 1
self.calls.append(func)
if self.call_count == 0:
for f in self.calls:
f()
if self.call_count <= 0:
self.ri.stop()
class FakeMetrics(object):
"""Fake Metrics object that records calls."""
def __init__(self):
"""Initialize calls."""
self.calls = []
def meter(self, name, count):
"""Record call to meter()."""
self.calls.append(("meter", name, count))
def gauge(self, name, val):
"""Record call to gauge()."""
self.calls.append(("gauge", name, val))
logger = logging.getLogger("storage.server")
logger.propagate = False
logger.setLevel(TRACE)
self.handler = MementoHandler()
self.handler.setLevel(TRACE)
logger.addHandler(self.handler)
self.addCleanup(logger.removeHandler, self.handler)
self.helper = Helper()
self.fake_metrics = FakeMetrics()
MetricsConnector.register_metrics("reactor_inspector",
instance=self.fake_metrics)
self.addCleanup(MetricsConnector.unregister_metrics)
self.ri = ReactorInspector(logger, self.helper.call, loop_time=.1)
self.helper.ri = self.ri
def __init__(self, interval, namespace_prefix, supervisor_rpc):
self.interval = interval
self.rpc = supervisor_rpc
self.process_cache = {}
self.metrics = MetricsConnector.new_metrics(namespace="%s.resources" %
(namespace_prefix))
self.logger = logging.getLogger("resources")
def __init__(self, interval, namespace_prefix, supervisor_rpc):
self.interval = interval
self.rpc = supervisor_rpc
self.process_cache = {}
self.metrics = MetricsConnector.new_metrics(
namespace="%s.resources" % (namespace_prefix))
self.logger = logging.getLogger("resources")
def setUp(self):
yield super(SSLProxyTestCase, self).setUp()
self.configure_logging()
self.ssl_service = ssl_proxy.ProxyService(self.ssl_cert,
self.ssl_key,
self.ssl_cert_chain,
0, # port
"localhost", self.port,
"ssl-proxy-test", 0)
# keep metrics in our MetricReceiver
self.metrics = MetricReceiver()
namespace = config.ssl_proxy.metrics_namespace
instance = MetricsConnector.new_txmetrics(connection=self.metrics,
namespace=namespace)
MetricsConnector.register_metrics("ssl-proxy", namespace, instance)
self._old_heartbeat_interval = config.ssl_proxy.heartbeat_interval
config.ssl_proxy.heartbeat_interval = self.ssl_proxy_heartbeat_interval
yield self.ssl_service.startService()
def test_register_and_lookup(self):
"""Test that we can look up different instances and record metrics."""
MetricsConnector.register_metrics("one")
MetricsConnector.register_metrics("two")
self.assertEqual("fake_one", MetricsConnector.get_metrics("one"))
self.assertEqual("fake_two", MetricsConnector.get_metrics("two"))
self.assertIdentical(MetricsConnector.get_metrics("one"),
MetricsConnector.get_metrics("one"))
self.assertRaises(ComponentLookupError,
MetricsConnector.get_metrics, "three")
MetricsConnector.unregister_metrics()
self.assertRaises(ComponentLookupError,
MetricsConnector.get_metrics, "one")
self.assertRaises(ComponentLookupError,
MetricsConnector.get_metrics, "two")
def setUp(self):
yield super(SSLProxyTestCase, self).setUp()
self.configure_logging()
self.ssl_service = ssl_proxy.ProxyService(self.ssl_cert,
self.ssl_key,
self.ssl_cert_chain,
0, # port
"localhost", self.port,
"ssl-proxy-test", 0)
# keep metrics in our MetricReceiver
self.metrics = MetricReceiver()
namespace = settings.ssl_proxy.METRICS_NAMESPACE
instance = MetricsConnector.new_txmetrics(connection=self.metrics,
namespace=namespace)
MetricsConnector.register_metrics("ssl-proxy", namespace, instance)
self.patch(settings.ssl_proxy, 'HEARTBEAT_INTERVAL',
self.ssl_proxy_heartbeat_interval)
yield self.ssl_service.startService()
def test_register_and_lookup(self):
"""Test that we can look up different instances and record metrics."""
MetricsConnector.register_metrics("one")
MetricsConnector.register_metrics("two")
self.assertEqual("fake_one", MetricsConnector.get_metrics("one"))
self.assertEqual("fake_two", MetricsConnector.get_metrics("two"))
self.assertIdentical(MetricsConnector.get_metrics("one"),
MetricsConnector.get_metrics("one"))
self.assertRaises(ComponentLookupError, MetricsConnector.get_metrics,
"three")
MetricsConnector.unregister_metrics()
self.assertRaises(ComponentLookupError, MetricsConnector.get_metrics,
"one")
self.assertRaises(ComponentLookupError, MetricsConnector.get_metrics,
"two")
def get_service_meter(self):
"""Return the meter for current environment and service."""
if self.service_meter is None:
with self.lock:
# Re-check, since another thread might have gotten the
# lock first.
if self.service_meter is None:
from metrics.metricsconnector import MetricsConnector
self.service_meter = MetricsConnector.new_metrics(
namespace=get_service_meter_name())
return self.service_meter
def setUp(self):
yield super(SSLProxyTestCase, self).setUp()
self.configure_logging()
self.ssl_service = ssl_proxy.ProxyService(
self.ssl_cert,
self.ssl_key,
self.ssl_cert_chain,
0, # port
"localhost",
self.port,
"ssl-proxy-test",
0)
# keep metrics in our MetricReceiver
self.metrics = MetricReceiver()
namespace = config.ssl_proxy.metrics_namespace
instance = MetricsConnector.new_txmetrics(connection=self.metrics,
namespace=namespace)
MetricsConnector.register_metrics("ssl-proxy", namespace, instance)
self._old_heartbeat_interval = config.ssl_proxy.heartbeat_interval
config.ssl_proxy.heartbeat_interval = self.ssl_proxy_heartbeat_interval
yield self.ssl_service.startService()
def get_service_meter(self):
"""Return the meter for current environment and service."""
if self.service_meter is None:
with self.lock:
# Re-check, since another thread might have gotten the
# lock first.
if self.service_meter is None:
from metrics.metricsconnector import MetricsConnector
self.service_meter = MetricsConnector.new_metrics(
namespace=get_service_meter_name())
return self.service_meter
def setUp(self):
"""Set up test."""
yield super(TestDelivery, self).setUp()
self.mocker = Mocker()
self.fake_reactor = DummyReactor()
self.content = self.mocker.mock()
self.node_owner_id = 1
self.node_uuid = uuid.uuid4()
self.node_hash = "hash:blah"
self.owner_id = 0
self.free_bytes = 0
self.node_shard_id = 'shard1'
self.node_volume_id = uuid.uuid4()
self.content_node = self.mocker.mock()
content_class = lambda _: self.content
MetricsConnector.register_metrics("sli", instance=ExtendedMetrics())
MetricsConnector.register_metrics("root", instance=ExtendedMetrics())
MetricsConnector.register_metrics("user", instance=ExtendedMetrics())
self.factory = StorageServerFactory(s3_host=None,
s3_port=None,
s3_key=None,
s3_ssl=False,
s3_secret=None,
content_class=content_class,
reactor=self.fake_reactor)
def __init__(self, logger, reactor_call, loop_time=3):
from metrics.metricsconnector import MetricsConnector
self.logger = logger
self.running = False
self.stopped = False
self.queue = Queue.Queue()
self.reactor_call = reactor_call
self.loop_time = loop_time
self.metrics = MetricsConnector.get_metrics("reactor_inspector")
self.last_responsive_ts = 0
self.reactor_thread = None
super(ReactorInspector, self).__init__()
self.daemon = True
def __init__(self, logger, reactor_call, loop_time=3):
from metrics.metricsconnector import MetricsConnector
self.logger = logger
self.running = False
self.stopped = False
self.queue = Queue.Queue()
self.reactor_call = reactor_call
self.loop_time = loop_time
self.metrics = MetricsConnector.get_metrics("reactor_inspector")
self.last_responsive_ts = 0
self.reactor_thread = None
super(ReactorInspector, self).__init__()
self.daemon = True
def setUp(self):
"""Set up test."""
yield super(TestDelivery, self).setUp()
self.mocker = Mocker()
self.fake_reactor = DummyReactor()
self.content = self.mocker.mock()
self.node_owner_id = 1
self.node_uuid = uuid.uuid4()
self.node_hash = "hash:blah"
self.owner_id = 0
self.free_bytes = 0
self.node_volume_id = uuid.uuid4()
self.content_node = self.mocker.mock()
content_class = lambda _: self.content
MetricsConnector.register_metrics("sli", instance=ExtendedMetrics())
MetricsConnector.register_metrics("root", instance=ExtendedMetrics())
MetricsConnector.register_metrics("user", instance=ExtendedMetrics())
self.factory = StorageServerFactory(
s3_host=None, s3_port=None, s3_key=None, s3_ssl=False,
s3_secret=None, content_class=content_class,
reactor=self.fake_reactor)
def test_register_fake_metrics(self):
"""Test that we can switch out a different metrics instance."""
MetricsConnector.register_metrics("abc", instance="totally_fake")
self.assertEqual("totally_fake", MetricsConnector.get_metrics("abc"))
def tearDown(self):
self.server = None
yield super(ProxyServerTest, self).tearDown()
MetricsConnector.unregister_metrics()
def tearDown(self):
"""Tear down the test."""
# restore the original instance
MetricsConnector.register_metrics(
"root", instance=self.service.factory.metrics)
return super(TestStats, self).tearDown()
def metrics(self):
"""Return the metrics instance for self.service."""
return MetricsConnector.get_metrics("root")
def test_register_with_different_namespace(self):
"""Register an instance with an aribrary lookup key."""
MetricsConnector.register_metrics("abc", "root.a.b.c")
self.assertEqual("fake_root.a.b.c",
MetricsConnector.get_metrics("abc"))
def tearDown(self):
"""Tear down the test."""
# restore the original instance
MetricsConnector.register_metrics(
"root", instance=self.service.factory.metrics)
return super(TestStats, self).tearDown()
def tearDown(self):
config.ssl_proxy.heartbeat_interval = self._old_heartbeat_interval
yield super(SSLProxyServiceTest, self).tearDown()
MetricsConnector.unregister_metrics()
def tearDown(self):
yield super(SSLProxyTestCase, self).tearDown()
yield self.ssl_service.stopService()
MetricsConnector.unregister_metrics()
def test_register_fake_metrics(self):
"""Test that we can switch out a different metrics instance."""
MetricsConnector.register_metrics("abc", instance="totally_fake")
self.assertEqual("totally_fake", MetricsConnector.get_metrics("abc"))
def test_register_with_different_namespace(self):
"""Register an instance with an aribrary lookup key."""
MetricsConnector.register_metrics("abc", "root.a.b.c")
self.assertEqual("fake_root.a.b.c",
MetricsConnector.get_metrics("abc"))
def tearDown(self):
self.server = None
yield super(ProxyServerTest, self).tearDown()
MetricsConnector.unregister_metrics()
def tearDown(self):
config.ssl_proxy.heartbeat_interval = self._old_heartbeat_interval
yield super(SSLProxyServiceTest, self).tearDown()
MetricsConnector.unregister_metrics()
def metrics(self):
"""Return the metrics instance for self.service."""
return MetricsConnector.get_metrics("root")
def tearDown(self):
yield super(SSLProxyServiceTest, self).tearDown()
MetricsConnector.unregister_metrics()
