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 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.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 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 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 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 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): 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 tearDown(self): yield super(SSLProxyServiceTest, self).tearDown() MetricsConnector.unregister_metrics()