class TestGauge(unittest.TestCase): def setUp(self): self.registry = CollectorRegistry() self.gauge = Gauge('g', 'help', registry=self.registry) def test_gauge(self): self.assertEqual(0, self.registry.get_sample_value('g')) self.gauge.inc() self.assertEqual(1, self.registry.get_sample_value('g')) self.gauge.dec(3) self.assertEqual(-2, self.registry.get_sample_value('g')) self.gauge.set(9) self.assertEqual(9, self.registry.get_sample_value('g')) def test_inprogress_function_decorator(self): self.assertEqual(0, self.registry.get_sample_value('g')) @self.gauge.track_inprogress() def f(): self.assertEqual(1, self.registry.get_sample_value('g')) self.assertEqual(([], None, None, None), inspect.getargspec(f)) f() self.assertEqual(0, self.registry.get_sample_value('g')) def test_inprogress_block_decorator(self): self.assertEqual(0, self.registry.get_sample_value('g')) with self.gauge.track_inprogress(): self.assertEqual(1, self.registry.get_sample_value('g')) self.assertEqual(0, self.registry.get_sample_value('g')) def test_gauge_function(self): x = {} self.gauge.set_function(lambda: len(x)) self.assertEqual(0, self.registry.get_sample_value('g')) self.gauge.inc() self.assertEqual(0, self.registry.get_sample_value('g')) x['a'] = None self.assertEqual(1, self.registry.get_sample_value('g')) def test_time_function_decorator(self): self.assertEqual(0, self.registry.get_sample_value('g')) @self.gauge.time() def f(): time.sleep(.001) self.assertEqual(([], None, None, None), inspect.getargspec(f)) f() self.assertNotEqual(0, self.registry.get_sample_value('g')) def test_time_block_decorator(self): self.assertEqual(0, self.registry.get_sample_value('g')) with self.gauge.time(): time.sleep(.001) self.assertNotEqual(0, self.registry.get_sample_value('g'))
def test_duplicate_metrics_raises(self): registry = CollectorRegistry() Counter('c_total', 'help', registry=registry) self.assertRaises(ValueError, Counter, 'c_total', 'help', registry=registry) self.assertRaises(ValueError, Gauge, 'c_total', 'help', registry=registry) self.assertRaises(ValueError, Gauge, 'c_created', 'help', registry=registry) Gauge('g_created', 'help', registry=registry) self.assertRaises(ValueError, Gauge, 'g_created', 'help', registry=registry) self.assertRaises(ValueError, Counter, 'g', 'help', registry=registry) Summary('s', 'help', registry=registry) self.assertRaises(ValueError, Summary, 's', 'help', registry=registry) self.assertRaises(ValueError, Gauge, 's_created', 'help', registry=registry) self.assertRaises(ValueError, Gauge, 's_sum', 'help', registry=registry) self.assertRaises(ValueError, Gauge, 's_count', 'help', registry=registry) # We don't currently expose quantiles, but let's prevent future # clashes anyway. self.assertRaises(ValueError, Gauge, 's', 'help', registry=registry) Histogram('h', 'help', registry=registry) self.assertRaises(ValueError, Histogram, 'h', 'help', registry=registry) # Clashes aggaint various suffixes. self.assertRaises(ValueError, Summary, 'h', 'help', registry=registry) self.assertRaises(ValueError, Gauge, 'h_count', 'help', registry=registry) self.assertRaises(ValueError, Gauge, 'h_sum', 'help', registry=registry) self.assertRaises(ValueError, Gauge, 'h_bucket', 'help', registry=registry) self.assertRaises(ValueError, Gauge, 'h_created', 'help', registry=registry) # The name of the histogram itself isn't taken. Gauge('h', 'help', registry=registry) Info('i', 'help', registry=registry) self.assertRaises(ValueError, Gauge, 'i_info', 'help', registry=registry)
class TestSummary(unittest.TestCase): def setUp(self): self.registry = CollectorRegistry() self.summary = Summary('s', 'help', registry=self.registry) def test_repr(self): self.assertEqual(repr(self.summary), "prometheus_client.metrics.Summary(s)") def test_summary(self): self.assertEqual(0, self.registry.get_sample_value('s_count')) self.assertEqual(0, self.registry.get_sample_value('s_sum')) self.summary.observe(10) self.assertEqual(1, self.registry.get_sample_value('s_count')) self.assertEqual(10, self.registry.get_sample_value('s_sum')) def test_function_decorator(self): self.assertEqual(0, self.registry.get_sample_value('s_count')) @self.summary.time() def f(): pass self.assertEqual(([], None, None, None), inspect.getargspec(f)) f() self.assertEqual(1, self.registry.get_sample_value('s_count')) def test_function_decorator_multithread(self): self.assertEqual(0, self.registry.get_sample_value('s_count')) summary2 = Summary('s2', 'help', registry=self.registry) workers = 3 duration = 0.1 pool = ThreadPoolExecutor(max_workers=workers) @self.summary.time() def f(): time.sleep(duration / 2) # Testing that different instances of timer do not interfere summary2.time()(lambda: time.sleep(duration / 2))() jobs = workers * 3 for i in range(jobs): pool.submit(f) pool.shutdown(wait=True) self.assertEqual(jobs, self.registry.get_sample_value('s_count')) rounding_coefficient = 0.9 total_expected_duration = jobs * duration * rounding_coefficient self.assertLess(total_expected_duration, self.registry.get_sample_value('s_sum')) self.assertLess(total_expected_duration / 2, self.registry.get_sample_value('s2_sum')) def test_function_decorator_reentrancy(self): self.assertEqual(0, self.registry.get_sample_value('s_count')) iterations = 2 sleep = 0.1 @self.summary.time() def f(i=1): time.sleep(sleep) if i == iterations: return f(i + 1) f() self.assertEqual(iterations, self.registry.get_sample_value('s_count')) # Arithmetic series with d == a_1 total_expected_duration = sleep * (iterations**2 + iterations) / 2 rounding_coefficient = 0.9 total_expected_duration *= rounding_coefficient self.assertLess(total_expected_duration, self.registry.get_sample_value('s_sum')) def test_block_decorator(self): self.assertEqual(0, self.registry.get_sample_value('s_count')) with self.summary.time(): pass self.assertEqual(1, self.registry.get_sample_value('s_count')) def test_timer_not_observable(self): s = Summary('test', 'help', labelnames=('label', ), registry=self.registry) try: s.time() except ValueError as e: self.assertIn('missing label values', str(e))
def setUp(self): self.registry = CollectorRegistry()
class TestGauge(unittest.TestCase): def setUp(self): self.registry = CollectorRegistry() self.gauge = Gauge('g', 'help', registry=self.registry) def test_repr(self): self.assertEqual(repr(self.gauge), "prometheus_client.metrics.Gauge(g)") def test_gauge(self): self.assertEqual(0, self.registry.get_sample_value('g')) self.gauge.inc() self.assertEqual(1, self.registry.get_sample_value('g')) self.gauge.dec(3) self.assertEqual(-2, self.registry.get_sample_value('g')) self.gauge.set(9) self.assertEqual(9, self.registry.get_sample_value('g')) def test_inprogress_function_decorator(self): self.assertEqual(0, self.registry.get_sample_value('g')) @self.gauge.track_inprogress() def f(): self.assertEqual(1, self.registry.get_sample_value('g')) self.assertEqual(([], None, None, None), inspect.getargspec(f)) f() self.assertEqual(0, self.registry.get_sample_value('g')) def test_inprogress_block_decorator(self): self.assertEqual(0, self.registry.get_sample_value('g')) with self.gauge.track_inprogress(): self.assertEqual(1, self.registry.get_sample_value('g')) self.assertEqual(0, self.registry.get_sample_value('g')) def test_gauge_function(self): x = {} self.gauge.set_function(lambda: len(x)) self.assertEqual(0, self.registry.get_sample_value('g')) self.gauge.inc() self.assertEqual(0, self.registry.get_sample_value('g')) x['a'] = None self.assertEqual(1, self.registry.get_sample_value('g')) def test_time_function_decorator(self): self.assertEqual(0, self.registry.get_sample_value('g')) @self.gauge.time() def f(): time.sleep(.001) self.assertEqual(([], None, None, None), inspect.getargspec(f)) f() self.assertNotEqual(0, self.registry.get_sample_value('g')) def test_function_decorator_multithread(self): self.assertEqual(0, self.registry.get_sample_value('g')) workers = 2 pool = ThreadPoolExecutor(max_workers=workers) @self.gauge.time() def f(duration): time.sleep(duration) expected_duration = 1 pool.submit(f, expected_duration) time.sleep(0.7 * expected_duration) pool.submit(f, expected_duration * 2) time.sleep(expected_duration) rounding_coefficient = 0.9 adjusted_expected_duration = expected_duration * rounding_coefficient self.assertLess(adjusted_expected_duration, self.registry.get_sample_value('g')) pool.shutdown(wait=True) def test_time_block_decorator(self): self.assertEqual(0, self.registry.get_sample_value('g')) with self.gauge.time(): time.sleep(.001) self.assertNotEqual(0, self.registry.get_sample_value('g')) def test_track_in_progress_not_observable(self): g = Gauge('test', 'help', labelnames=('label', ), registry=self.registry) try: g.track_inprogress() except ValueError as e: self.assertIn('missing label values', str(e)) def test_timer_not_observable(self): g = Gauge('test', 'help', labelnames=('label', ), registry=self.registry) try: g.time() except ValueError as e: self.assertIn('missing label values', str(e))
def setUp(self): self.registry = CollectorRegistry() self.counter = Counter('c_total', 'help', registry=self.registry)
class TestMetricWrapper(unittest.TestCase): def setUp(self): self.registry = CollectorRegistry() self.counter = Counter('c_total', 'help', labelnames=['l'], registry=self.registry) self.two_labels = Counter('two', 'help', labelnames=['a', 'b'], registry=self.registry) def test_child(self): self.counter.labels('x').inc() self.assertEqual(1, self.registry.get_sample_value('c_total', {'l': 'x'})) self.two_labels.labels('x', 'y').inc(2) self.assertEqual( 2, self.registry.get_sample_value('two_total', { 'a': 'x', 'b': 'y' })) def test_remove(self): self.counter.labels('x').inc() self.counter.labels('y').inc(2) self.assertEqual(1, self.registry.get_sample_value('c_total', {'l': 'x'})) self.assertEqual(2, self.registry.get_sample_value('c_total', {'l': 'y'})) self.counter.remove('x') self.assertEqual(None, self.registry.get_sample_value('c_total', {'l': 'x'})) self.assertEqual(2, self.registry.get_sample_value('c_total', {'l': 'y'})) def test_incorrect_label_count_raises(self): self.assertRaises(ValueError, self.counter.labels) self.assertRaises(ValueError, self.counter.labels, 'a', 'b') self.assertRaises(ValueError, self.counter.remove) self.assertRaises(ValueError, self.counter.remove, 'a', 'b') def test_labels_on_labels(self): with pytest.raises(ValueError): self.counter.labels('a').labels('b') def test_labels_coerced_to_string(self): self.counter.labels(None).inc() self.counter.labels(l=None).inc() self.assertEqual( 2, self.registry.get_sample_value('c_total', {'l': 'None'})) self.counter.remove(None) self.assertEqual( None, self.registry.get_sample_value('c_total', {'l': 'None'})) def test_non_string_labels_raises(self): class Test(object): __str__ = None self.assertRaises(TypeError, self.counter.labels, Test()) self.assertRaises(TypeError, self.counter.labels, l=Test()) def test_namespace_subsystem_concatenated(self): c = Counter('c_total', 'help', namespace='a', subsystem='b', registry=self.registry) c.inc() self.assertEqual(1, self.registry.get_sample_value('a_b_c_total')) def test_labels_by_kwarg(self): self.counter.labels(l='x').inc() self.assertEqual(1, self.registry.get_sample_value('c_total', {'l': 'x'})) self.assertRaises(ValueError, self.counter.labels, l='x', m='y') self.assertRaises(ValueError, self.counter.labels, m='y') self.assertRaises(ValueError, self.counter.labels) self.two_labels.labels(a='x', b='y').inc() self.assertEqual( 1, self.registry.get_sample_value('two_total', { 'a': 'x', 'b': 'y' })) self.assertRaises(ValueError, self.two_labels.labels, a='x', b='y', c='z') self.assertRaises(ValueError, self.two_labels.labels, a='x', c='z') self.assertRaises(ValueError, self.two_labels.labels, b='y', c='z') self.assertRaises(ValueError, self.two_labels.labels, c='z') self.assertRaises(ValueError, self.two_labels.labels) self.assertRaises(ValueError, self.two_labels.labels, {'a': 'x'}, b='y') def test_invalid_names_raise(self): self.assertRaises(ValueError, Counter, '', 'help') self.assertRaises(ValueError, Counter, '^', 'help') self.assertRaises(ValueError, Counter, '', 'help', namespace='&') self.assertRaises(ValueError, Counter, '', 'help', subsystem='(') self.assertRaises(ValueError, Counter, 'c_total', '', labelnames=['^']) self.assertRaises(ValueError, Counter, 'c_total', '', labelnames=['a:b']) self.assertRaises(ValueError, Counter, 'c_total', '', labelnames=['__reserved']) self.assertRaises(ValueError, Summary, 'c_total', '', labelnames=['quantile']) def test_empty_labels_list(self): Histogram('h', 'help', [], registry=self.registry) self.assertEqual(0, self.registry.get_sample_value('h_sum')) def test_unit_appended(self): Histogram('h', 'help', [], registry=self.registry, unit="seconds") self.assertEqual(0, self.registry.get_sample_value('h_seconds_sum')) def test_unit_notappended(self): Histogram('h_seconds', 'help', [], registry=self.registry, unit="seconds") self.assertEqual(0, self.registry.get_sample_value('h_seconds_sum')) def test_no_units_for_info_enum(self): self.assertRaises(ValueError, Info, 'foo', 'help', unit="x") self.assertRaises(ValueError, Enum, 'foo', 'help', unit="x") def test_name_cleanup_before_unit_append(self): self.assertEqual(self.counter._name, 'c') self.c = Counter('c_total', 'help', unit="total", labelnames=['l'], registry=self.registry) self.assertEqual(self.c._name, 'c_total')
def r_value(): REGISTRY = CollectorRegistry(auto_describe=False) gauge_msg_diff_detail = Gauge( "rocketmq_msg_diff_detail", "message count that not be consumed.", [ 'topic', 'consumerGroup', 'broker', 'queueId', 'consumerClientIP', 'consumerClientPID' ], registry=REGISTRY) gauge_msg_diff_topic = Gauge("rocketmq_msg_diff_topic", "message count that not be consumed.", ['topic'], registry=REGISTRY) gauge_msg_diff_consumergroup = Gauge("rocketmq_msg_diff_consumergroup", "message count that not be consumed.", ['consumerGroup'], registry=REGISTRY) gauge_msg_diff_topic_consumergroup = Gauge( "rocketmq_msg_diff_topic_consumergroup", "message count that not be consumed.", ['topic', 'consumerGroup'], registry=REGISTRY) gauge_msg_diff_broker = Gauge("rocketmq_msg_diff_broker", "message count that not be consumed.", ['broker'], registry=REGISTRY) gauge_msg_diff_queue = Gauge("rocketmq_msg_diff_queue", "message count that not be consumed.", ['broker', 'queueId'], registry=REGISTRY) gauge_msg_diff_clientinfo = Gauge( "rocketmq_msg_diff_clientinfo", "message count that not be consumed.", ['consumerClientIP', 'consumerClientPID'], registry=REGISTRY) env_dist = os.environ rocketmq_console = env_dist.get('ROCKETMQ_CONSOLE') #msg_diff = rocketmq_service.msg_diff('rocketmq-console-ip:7000') msg_diff = rocketmq_service.msg_diff(rocketmq_console) #msg_diff = rocketmq_service.msg_diff('172.16.13.168:7000') msg_diff_details = msg_diff['msg_diff_details'] for index, info in enumerate(msg_diff_details): gauge_msg_diff_detail.labels(info['topic'], info['consumerGroup'], info['broker'], info['queueId'], info['consumerClientIP'], info['consumerClientPID']).set( int(info['diff'])) msg_diff_topics = msg_diff['msg_diff_topics'] list_topic_name = msg_diff_topics.keys() for index, topic_name in enumerate(list_topic_name): gauge_msg_diff_topic.labels(msg_diff_topics[topic_name]['topic']).set( int(msg_diff_topics[topic_name]['diff'])) msg_diff_consumergroups = msg_diff['msg_diff_consumergroups'] list_cg_name = msg_diff_consumergroups.keys() for index, cg_name in enumerate(list_cg_name): gauge_msg_diff_consumergroup.labels( msg_diff_consumergroups[cg_name]['consumerGroup']).set( int(msg_diff_consumergroups[cg_name]['diff'])) msg_diff_topics_consumergroups = msg_diff['msg_diff_topics_consumergroups'] list_topic_consumergroup_name = msg_diff_topics_consumergroups.keys() for index, topic_consumergroup_name in enumerate( list_topic_consumergroup_name): gauge_msg_diff_topic_consumergroup.labels( msg_diff_topics_consumergroups[topic_consumergroup_name]['topic'], msg_diff_topics_consumergroups[topic_consumergroup_name] ['consumerGroup']).set( int(msg_diff_topics_consumergroups[topic_consumergroup_name] ['diff'])) msg_diff_brokers = msg_diff['msg_diff_brokers'] list_broker_name = msg_diff_brokers.keys() for index, broker_name in enumerate(list_broker_name): gauge_msg_diff_broker.labels( msg_diff_brokers[broker_name]['broker']).set( int(msg_diff_brokers[broker_name]['diff'])) msg_diff_queues = msg_diff['msg_diff_queues'] list_queue_name = msg_diff_queues.keys() for index, queue_name in enumerate(list_queue_name): gauge_msg_diff_queue.labels( msg_diff_queues[queue_name]['broker'], msg_diff_queues[queue_name]['queueId']).set( int(msg_diff_queues[queue_name]['diff'])) msg_diff_clientinfos = msg_diff['msg_diff_clientinfos'] list_client_name = msg_diff_clientinfos.keys() for index, client_name in enumerate(list_client_name): gauge_msg_diff_clientinfo.labels( msg_diff_clientinfos[client_name]['consumerClientIP'], msg_diff_clientinfos[client_name]['consumerClientPID']).set( int(msg_diff_clientinfos[client_name]['diff'])) res = prometheus_client.generate_latest(gauge_msg_diff_detail) + bytes("\n", encoding = "utf8") \ + prometheus_client.generate_latest(gauge_msg_diff_topic) + bytes("\n", encoding = "utf8") \ + prometheus_client.generate_latest(gauge_msg_diff_consumergroup) + bytes("\n", encoding = "utf8") \ + prometheus_client.generate_latest(gauge_msg_diff_topic_consumergroup) + bytes("\n", encoding = "utf8") \ + prometheus_client.generate_latest(gauge_msg_diff_broker) + bytes("\n", encoding = "utf8") \ + prometheus_client.generate_latest(gauge_msg_diff_queue) + bytes("\n", encoding = "utf8") \ + prometheus_client.generate_latest(gauge_msg_diff_clientinfo) + bytes("\n", encoding = "utf8") return Response(res, mimetype="text/plain")
def setUp(self): self.tempdir = tempfile.mkdtemp() os.environ['prometheus_multiproc_dir'] = self.tempdir values.ValueClass = MultiProcessValue(lambda: 123) self.registry = CollectorRegistry() self.collector = MultiProcessCollector(self.registry, self.tempdir)
class TestGauge(unittest.TestCase): def setUp(self): self.registry = CollectorRegistry() self.gauge = Gauge('g', 'help', registry=self.registry) def test_gauge(self): self.assertEqual(0, self.registry.get_sample_value('g')) self.gauge.inc() self.assertEqual(1, self.registry.get_sample_value('g')) self.gauge.dec(3) self.assertEqual(-2, self.registry.get_sample_value('g')) self.gauge.set(9) self.assertEqual(9, self.registry.get_sample_value('g')) def test_inprogress_function_decorator(self): self.assertEqual(0, self.registry.get_sample_value('g')) @self.gauge.track_inprogress() def f(): self.assertEqual(1, self.registry.get_sample_value('g')) self.assertEqual(([], None, None, None), inspect.getargspec(f)) f() self.assertEqual(0, self.registry.get_sample_value('g')) def test_inprogress_block_decorator(self): self.assertEqual(0, self.registry.get_sample_value('g')) with self.gauge.track_inprogress(): self.assertEqual(1, self.registry.get_sample_value('g')) self.assertEqual(0, self.registry.get_sample_value('g')) def test_gauge_function(self): x = {} self.gauge.set_function(lambda: len(x)) self.assertEqual(0, self.registry.get_sample_value('g')) self.gauge.inc() self.assertEqual(0, self.registry.get_sample_value('g')) x['a'] = None self.assertEqual(1, self.registry.get_sample_value('g')) def test_time_function_decorator(self): self.assertEqual(0, self.registry.get_sample_value('g')) @self.gauge.time() def f(): time.sleep(.001) self.assertEqual(([], None, None, None), inspect.getargspec(f)) f() self.assertNotEqual(0, self.registry.get_sample_value('g')) def test_function_decorator_multithread(self): self.assertEqual(0, self.registry.get_sample_value('g')) workers = 2 pool = ThreadPoolExecutor(max_workers=workers) @self.gauge.time() def f(duration): time.sleep(duration) expected_duration = 1 pool.submit(f, expected_duration) time.sleep(0.7 * expected_duration) pool.submit(f, expected_duration * 2) time.sleep(expected_duration) rounding_coefficient = 0.9 adjusted_expected_duration = expected_duration * rounding_coefficient self.assertLess(adjusted_expected_duration, self.registry.get_sample_value('g')) pool.shutdown(wait=True) def test_time_block_decorator(self): self.assertEqual(0, self.registry.get_sample_value('g')) with self.gauge.time(): time.sleep(.001) self.assertNotEqual(0, self.registry.get_sample_value('g'))
def prom_exporter(): # Sign in first sign_in() vendor_xpath = [ '/html/body/div[7]/div[1]/div/div[1]/div/div[2]/div[1]/div/a/text()', '/html/body/div[6]/div[1]/div/div[1]/div/div[2]/div[1]/div/a/text()' ] location_xpath = [ '/html/body/div[7]/div[1]/div/div[1]/div/div[2]/ul/li[3]/text()', '/html/body/div[6]/div[1]/div/div[1]/div/div[2]/ul/li[3]/text()' ] online_date_xpath = [ '/html/body/div[7]/div[1]/div/div[1]/div/div[2]/ul/li[2]/text()', '/html/body/div[6]/div[1]/div/div[1]/div/div[2]/ul/li[2]/text()' ] registered_capital_xpath = [ '/html/body/div[7]/div[1]/div/div[1]/div/div[2]/ul/li[1]/span[2]/text()', '/html/body/div[6]/div[1]/div/div[1]/div/div[2]/ul/li[1]/span[2]/text()' ] vendor_href_xpath = [ '/html/body/div[7]/div[1]/div/div[1]/div/div[1]/div[1]/a/@href', '/html/body/div[6]/div[1]/div/div[1]/div/div[1]/div[1]/a/@href' ] durations_divs_xpath1 = '/html/body/div[7]/div[1]/div/div[3]/div' # Begin with [2] durations_divs_xpath2 = '/html/body/div[6]/div[1]/div/div[3]/div' # Begin with [2] durations_divs_xpath3 = '/html/body/div[6]/div[1]/div/div[4]/div' # Begin with [2], for 2nd investment in 1st one duration_h_xpath = ['div/h4/text()'] global beginner_p_xpath beginner_p_xpath = 'div/p' solutions_lis_xpath = 'ul/li' solution_name_div_xpath = ['div[1]/div/text()'] solution_min_amount_span_xpath = ['div[2]/div[1]/div[1]/span[1]/text()'] solution_all_roi_span_xpath = ['div[2]/div[2]/div[1]/span[1]/text()'] solution_all_roi_rate_span_xpath = ['div[2]/div[3]/div[1]/span/text()'] solution_p2peye_return_span_xpath = [ 'div[2]/div[4]/div[1]/span[1]/text()', 'div[2]/div[3]/div[1]/span[1]/text()' ] # Create a metric registry registry = CollectorRegistry() # Define metrics i = Info('build', '', registry=registry) i.info({'version': update_date, 'github': github_repo}) g_p2peye_rebate = Gauge( 'p2peye_rebate', 'P2peye rebates', [ 'user', 'vendor', 'location', 'online_date', 'registered_capital', 'url', 'comment_url', 'duration', 'beginner_flag', 'solution', 'min_amount', 'all_roi', 'all_roi_rate', 'p2peye_return', 'return_per_day' ], registry=registry) # Separately get rebates for beginners and not def scrape_rebates(urls, for_beginner): # Get metric properties for vendor_url in urls: # Get XML response_xml = send_request(vendor_url) if not response_xml: continue # Assign basic properties of vendor property_user = user_name property_vendor = etree_value(response_xml, vendor_url, vendor_xpath)[0] property_location = etree_value(response_xml, vendor_url, location_xpath)[1].split('\n')[0] property_online_date = etree_value( response_xml, vendor_url, online_date_xpath)[1].split('\n')[0] property_registered_capital = etree_value( response_xml, vendor_url, registered_capital_xpath)[0] if property_registered_capital != DEFAULT_PROPERTY[0]: property_registered_capital = str( round(float(property_registered_capital) * 10000)) # 10000 as unit property_url = vendor_url property_comment_url = 'https:' + etree_value( response_xml, vendor_url, vendor_href_xpath)[0] + '/comment/' # Assign detailed properties of specific rebate durations_etree = html.etree.HTML( response_xml) # durations_solutions if for_beginner == 'yes' and etree_value( response_xml, vendor_url, ['/html/body/div[6]/div[1]/div/div[3]/a/text()' ])[0].find('多次') != -1: durations_divs = durations_etree.xpath(durations_divs_xpath3) else: durations_divs = durations_etree.xpath(durations_divs_xpath1) if len(durations_divs) == 0: durations_divs = durations_etree.xpath( durations_divs_xpath2) for i in range(1, len(durations_divs)): # Begin with [1] property_duration = etree_value(durations_divs[i], vendor_url, duration_h_xpath, 'etree')[0] if for_beginner == 'yes': property_beginner_flag = '是' elif for_beginner == 'no': property_beginner_flag = '否' solutions_lis = durations_divs[i].xpath(solutions_lis_xpath) # Get properties of a specific solution for solution_li in solutions_lis: property_solution_name = etree_value( solution_li, vendor_url, solution_name_div_xpath, 'etree')[0] property_min_amount = etree_value( solution_li, vendor_url, solution_min_amount_span_xpath, 'etree')[0] property_all_roi = etree_value( solution_li, vendor_url, solution_all_roi_span_xpath, 'etree')[0] property_all_roi_rate = str( etree_value(solution_li, vendor_url, solution_all_roi_rate_span_xpath, 'etree')[0]) + '%' property_p2peye_return = etree_value( solution_li, vendor_url, solution_p2peye_return_span_xpath, 'etree')[0] # Get metrics values # Assign metrics values # Compute return_per_day if property_all_roi != DEFAULT_PROPERTY[0] and property_min_amount != DEFAULT_PROPERTY[0] \ and property_duration != DEFAULT_PROPERTY[0]: property_10k = float(property_min_amount) / 10000 property_day = property_duration.replace('个', '').replace( '及以上', '') if property_day.find('天') != -1: property_day = int(property_day.replace('天', '')) elif property_day.find('月') != -1: property_day = int(property_day.replace('月', '')) * 30 elif property_day.find('年') != -1: property_day = int(property_day.replace('年', '')) * 365 # Return per day per 10k property_return_per_day = str( round( float(property_all_roi) / property_day / property_10k, 2)) else: property_return_per_day = DEFAULT_PROPERTY[0] g_p2peye_rebate.labels( user=property_user, vendor=property_vendor, location=property_location, online_date=property_online_date, registered_capital=property_registered_capital, url=property_url, comment_url=property_comment_url, duration=property_duration, beginner_flag=property_beginner_flag, solution=property_solution_name, min_amount=property_min_amount, all_roi=property_all_roi, all_roi_rate=property_all_roi_rate, p2peye_return=property_p2peye_return, return_per_day=property_return_per_day).set(1) scrape_rebates(get_vendors(for_beginner='yes'), for_beginner='yes') scrape_rebates(get_vendors(for_beginner='no'), for_beginner='no') # Respond with metrics return Response(generate_latest(registry), mimetype="text/plain")
def test_unregister_works(self): registry = CollectorRegistry() s = Summary('s', 'help', registry=registry) self.assertRaises(ValueError, Gauge, 's_count', 'help', registry=registry) registry.unregister(s) Gauge('s_count', 'help', registry=registry)
def setUp(self): self.registry = CollectorRegistry() self.counter = Counter('c_total', 'help', labelnames=['l'], registry=self.registry) self.two_labels = Counter('two', 'help', labelnames=['a', 'b'], registry=self.registry)
def setUp(self): self.registry = CollectorRegistry() self.enum = Enum('e', 'help', states=['a', 'b', 'c'], registry=self.registry) self.labels = Enum('el', 'help', ['l'], states=['a', 'b', 'c'], registry=self.registry)
def setUp(self): self.registry = CollectorRegistry() self.histogram = Histogram('h', 'help', registry=self.registry) self.labels = Histogram('hl', 'help', ['l'], registry=self.registry)
def setUp(self): self.registry = CollectorRegistry() fp, self.tmpfl = tempfile.mkstemp() os.close(fp)
class TestCounter(unittest.TestCase): def setUp(self): self.registry = CollectorRegistry() self.counter = Counter('c_total', 'help', registry=self.registry) def test_increment(self): self.assertEqual(0, self.registry.get_sample_value('c_total')) self.counter.inc() self.assertEqual(1, self.registry.get_sample_value('c_total')) self.counter.inc(7) self.assertEqual(8, self.registry.get_sample_value('c_total')) def test_repr(self): self.assertEqual(repr(self.counter), "prometheus_client.metrics.Counter(c)") def test_negative_increment_raises(self): self.assertRaises(ValueError, self.counter.inc, -1) def test_function_decorator(self): @self.counter.count_exceptions(ValueError) def f(r): if r: raise ValueError else: raise TypeError self.assertEqual((["r"], None, None, None), inspect.getargspec(f)) try: f(False) except TypeError: pass self.assertEqual(0, self.registry.get_sample_value('c_total')) try: f(True) except ValueError: pass self.assertEqual(1, self.registry.get_sample_value('c_total')) def test_block_decorator(self): with self.counter.count_exceptions(): pass self.assertEqual(0, self.registry.get_sample_value('c_total')) raised = False try: with self.counter.count_exceptions(): raise ValueError except: raised = True self.assertTrue(raised) self.assertEqual(1, self.registry.get_sample_value('c_total')) def test_count_exceptions_not_observable(self): counter = Counter('counter', 'help', labelnames=('label', ), registry=self.registry) try: counter.count_exceptions() except ValueError as e: self.assertIn('missing label values', str(e))
def test_file_syncpath(self): registry = CollectorRegistry() self.assertRaises(ValueError, MultiProcessCollector, registry, self.tmpfl)
def setUp(self): self.registry = CollectorRegistry() self.info = Info('i', 'help', registry=self.registry) self.labels = Info('il', 'help', ['l'], registry=self.registry)
class TestMultiProcess(unittest.TestCase): def setUp(self): self.tempdir = tempfile.mkdtemp() os.environ['PROMETHEUS_MULTIPROC_DIR'] = self.tempdir values.ValueClass = MultiProcessValue(lambda: 123) self.registry = CollectorRegistry() self.collector = MultiProcessCollector(self.registry) @property def _value_class(self): return def tearDown(self): del os.environ['PROMETHEUS_MULTIPROC_DIR'] shutil.rmtree(self.tempdir) values.ValueClass = MutexValue def test_counter_adds(self): c1 = Counter('c', 'help', registry=None) values.ValueClass = MultiProcessValue(lambda: 456) c2 = Counter('c', 'help', registry=None) self.assertEqual(0, self.registry.get_sample_value('c_total')) c1.inc(1) c2.inc(2) self.assertEqual(3, self.registry.get_sample_value('c_total')) def test_summary_adds(self): s1 = Summary('s', 'help', registry=None) values.ValueClass = MultiProcessValue(lambda: 456) s2 = Summary('s', 'help', registry=None) self.assertEqual(0, self.registry.get_sample_value('s_count')) self.assertEqual(0, self.registry.get_sample_value('s_sum')) s1.observe(1) s2.observe(2) self.assertEqual(2, self.registry.get_sample_value('s_count')) self.assertEqual(3, self.registry.get_sample_value('s_sum')) def test_histogram_adds(self): h1 = Histogram('h', 'help', registry=None) values.ValueClass = MultiProcessValue(lambda: 456) h2 = Histogram('h', 'help', registry=None) self.assertEqual(0, self.registry.get_sample_value('h_count')) self.assertEqual(0, self.registry.get_sample_value('h_sum')) self.assertEqual( 0, self.registry.get_sample_value('h_bucket', {'le': '5.0'})) h1.observe(1) h2.observe(2) self.assertEqual(2, self.registry.get_sample_value('h_count')) self.assertEqual(3, self.registry.get_sample_value('h_sum')) self.assertEqual( 2, self.registry.get_sample_value('h_bucket', {'le': '5.0'})) def test_gauge_all(self): g1 = Gauge('g', 'help', registry=None) values.ValueClass = MultiProcessValue(lambda: 456) g2 = Gauge('g', 'help', registry=None) self.assertEqual(0, self.registry.get_sample_value('g', {'pid': '123'})) self.assertEqual(0, self.registry.get_sample_value('g', {'pid': '456'})) g1.set(1) g2.set(2) mark_process_dead(123) self.assertEqual(1, self.registry.get_sample_value('g', {'pid': '123'})) self.assertEqual(2, self.registry.get_sample_value('g', {'pid': '456'})) def test_gauge_liveall(self): g1 = Gauge('g', 'help', registry=None, multiprocess_mode='liveall') values.ValueClass = MultiProcessValue(lambda: 456) g2 = Gauge('g', 'help', registry=None, multiprocess_mode='liveall') self.assertEqual(0, self.registry.get_sample_value('g', {'pid': '123'})) self.assertEqual(0, self.registry.get_sample_value('g', {'pid': '456'})) g1.set(1) g2.set(2) self.assertEqual(1, self.registry.get_sample_value('g', {'pid': '123'})) self.assertEqual(2, self.registry.get_sample_value('g', {'pid': '456'})) mark_process_dead(123, os.environ['PROMETHEUS_MULTIPROC_DIR']) self.assertEqual(None, self.registry.get_sample_value('g', {'pid': '123'})) self.assertEqual(2, self.registry.get_sample_value('g', {'pid': '456'})) def test_gauge_min(self): g1 = Gauge('g', 'help', registry=None, multiprocess_mode='min') values.ValueClass = MultiProcessValue(lambda: 456) g2 = Gauge('g', 'help', registry=None, multiprocess_mode='min') self.assertEqual(0, self.registry.get_sample_value('g')) g1.set(1) g2.set(2) self.assertEqual(1, self.registry.get_sample_value('g')) def test_gauge_max(self): g1 = Gauge('g', 'help', registry=None, multiprocess_mode='max') values.ValueClass = MultiProcessValue(lambda: 456) g2 = Gauge('g', 'help', registry=None, multiprocess_mode='max') self.assertEqual(0, self.registry.get_sample_value('g')) g1.set(1) g2.set(2) self.assertEqual(2, self.registry.get_sample_value('g')) def test_gauge_livesum(self): g1 = Gauge('g', 'help', registry=None, multiprocess_mode='livesum') values.ValueClass = MultiProcessValue(lambda: 456) g2 = Gauge('g', 'help', registry=None, multiprocess_mode='livesum') self.assertEqual(0, self.registry.get_sample_value('g')) g1.set(1) g2.set(2) self.assertEqual(3, self.registry.get_sample_value('g')) mark_process_dead(123, os.environ['PROMETHEUS_MULTIPROC_DIR']) self.assertEqual(2, self.registry.get_sample_value('g')) def test_namespace_subsystem(self): c1 = Counter('c', 'help', registry=None, namespace='ns', subsystem='ss') c1.inc(1) self.assertEqual(1, self.registry.get_sample_value('ns_ss_c_total')) def test_counter_across_forks(self): pid = 0 values.ValueClass = MultiProcessValue(lambda: pid) c1 = Counter('c', 'help', registry=None) self.assertEqual(0, self.registry.get_sample_value('c_total')) c1.inc(1) c1.inc(1) pid = 1 c1.inc(1) self.assertEqual(3, self.registry.get_sample_value('c_total')) self.assertEqual(1, c1._value.get()) def test_initialization_detects_pid_change(self): pid = 0 values.ValueClass = MultiProcessValue(lambda: pid) # can not inspect the files cache directly, as it's a closure, so we # check for the actual files themselves def files(): fs = os.listdir(os.environ['PROMETHEUS_MULTIPROC_DIR']) fs.sort() return fs c1 = Counter('c1', 'c1', registry=None) self.assertEqual(files(), ['counter_0.db']) c2 = Counter('c2', 'c2', registry=None) self.assertEqual(files(), ['counter_0.db']) pid = 1 c3 = Counter('c3', 'c3', registry=None) self.assertEqual(files(), ['counter_0.db', 'counter_1.db']) @unittest.skipIf(sys.version_info < (2, 7), "Test requires Python 2.7+.") def test_collect(self): pid = 0 values.ValueClass = MultiProcessValue(lambda: pid) labels = dict((i, i) for i in 'abcd') def add_label(key, value): l = labels.copy() l[key] = value return l c = Counter('c', 'help', labelnames=labels.keys(), registry=None) g = Gauge('g', 'help', labelnames=labels.keys(), registry=None) h = Histogram('h', 'help', labelnames=labels.keys(), registry=None) c.labels(**labels).inc(1) g.labels(**labels).set(1) h.labels(**labels).observe(1) pid = 1 c.labels(**labels).inc(1) g.labels(**labels).set(1) h.labels(**labels).observe(5) metrics = dict((m.name, m) for m in self.collector.collect()) self.assertEqual(metrics['c'].samples, [Sample('c_total', labels, 2.0)]) metrics['g'].samples.sort(key=lambda x: x[1]['pid']) self.assertEqual(metrics['g'].samples, [ Sample('g', add_label('pid', '0'), 1.0), Sample('g', add_label('pid', '1'), 1.0), ]) metrics['h'].samples.sort( key=lambda x: (x[0], float(x[1].get('le', 0)))) expected_histogram = [ Sample('h_bucket', add_label('le', '0.005'), 0.0), Sample('h_bucket', add_label('le', '0.01'), 0.0), Sample('h_bucket', add_label('le', '0.025'), 0.0), Sample('h_bucket', add_label('le', '0.05'), 0.0), Sample('h_bucket', add_label('le', '0.075'), 0.0), Sample('h_bucket', add_label('le', '0.1'), 0.0), Sample('h_bucket', add_label('le', '0.25'), 0.0), Sample('h_bucket', add_label('le', '0.5'), 0.0), Sample('h_bucket', add_label('le', '0.75'), 0.0), Sample('h_bucket', add_label('le', '1.0'), 1.0), Sample('h_bucket', add_label('le', '2.5'), 1.0), Sample('h_bucket', add_label('le', '5.0'), 2.0), Sample('h_bucket', add_label('le', '7.5'), 2.0), Sample('h_bucket', add_label('le', '10.0'), 2.0), Sample('h_bucket', add_label('le', '+Inf'), 2.0), Sample('h_count', labels, 2.0), Sample('h_sum', labels, 6.0), ] self.assertEqual(metrics['h'].samples, expected_histogram) @unittest.skipIf(sys.version_info < (2, 7), "Test requires Python 2.7+.") def test_merge_no_accumulate(self): pid = 0 values.ValueClass = MultiProcessValue(lambda: pid) labels = dict((i, i) for i in 'abcd') def add_label(key, value): l = labels.copy() l[key] = value return l h = Histogram('h', 'help', labelnames=labels.keys(), registry=None) h.labels(**labels).observe(1) pid = 1 h.labels(**labels).observe(5) path = os.path.join(os.environ['PROMETHEUS_MULTIPROC_DIR'], '*.db') files = glob.glob(path) metrics = dict( (m.name, m) for m in self.collector.merge(files, accumulate=False)) metrics['h'].samples.sort( key=lambda x: (x[0], float(x[1].get('le', 0)))) expected_histogram = [ Sample('h_bucket', add_label('le', '0.005'), 0.0), Sample('h_bucket', add_label('le', '0.01'), 0.0), Sample('h_bucket', add_label('le', '0.025'), 0.0), Sample('h_bucket', add_label('le', '0.05'), 0.0), Sample('h_bucket', add_label('le', '0.075'), 0.0), Sample('h_bucket', add_label('le', '0.1'), 0.0), Sample('h_bucket', add_label('le', '0.25'), 0.0), Sample('h_bucket', add_label('le', '0.5'), 0.0), Sample('h_bucket', add_label('le', '0.75'), 0.0), Sample('h_bucket', add_label('le', '1.0'), 1.0), Sample('h_bucket', add_label('le', '2.5'), 0.0), Sample('h_bucket', add_label('le', '5.0'), 1.0), Sample('h_bucket', add_label('le', '7.5'), 0.0), Sample('h_bucket', add_label('le', '10.0'), 0.0), Sample('h_bucket', add_label('le', '+Inf'), 0.0), Sample('h_sum', labels, 6.0), ] self.assertEqual(metrics['h'].samples, expected_histogram) def test_missing_gauge_file_during_merge(self): # These files don't exist, just like if mark_process_dead(9999999) had been # called during self.collector.collect(), after the glob found it # but before the merge actually happened. # This should not raise and return no metrics self.assertFalse( self.collector.merge([ os.path.join(self.tempdir, 'gauge_liveall_9999999.db'), os.path.join(self.tempdir, 'gauge_livesum_9999999.db'), ]))
class TestMetricFamilies(unittest.TestCase): def setUp(self): self.registry = CollectorRegistry() def custom_collector(self, metric_family): class CustomCollector(object): def collect(self): return [metric_family] self.registry.register(CustomCollector()) def test_untyped(self): self.custom_collector(UntypedMetricFamily('u', 'help', value=1)) self.assertEqual(1, self.registry.get_sample_value('u', {})) def test_untyped_labels(self): cmf = UntypedMetricFamily('u', 'help', labels=['a', 'c']) cmf.add_metric(['b', 'd'], 2) self.custom_collector(cmf) self.assertEqual( 2, self.registry.get_sample_value('u', { 'a': 'b', 'c': 'd' })) def test_untyped_unit(self): self.custom_collector( UntypedMetricFamily('u', 'help', value=1, unit='unit')) self.assertEqual(1, self.registry.get_sample_value('u_unit', {})) def test_counter(self): self.custom_collector(CounterMetricFamily('c_total', 'help', value=1)) self.assertEqual(1, self.registry.get_sample_value('c_total', {})) def test_counter_total(self): self.custom_collector(CounterMetricFamily('c_total', 'help', value=1)) self.assertEqual(1, self.registry.get_sample_value('c_total', {})) def test_counter_labels(self): cmf = CounterMetricFamily('c_total', 'help', labels=['a', 'c_total']) cmf.add_metric(['b', 'd'], 2) self.custom_collector(cmf) self.assertEqual( 2, self.registry.get_sample_value('c_total', { 'a': 'b', 'c_total': 'd' })) def test_gauge(self): self.custom_collector(GaugeMetricFamily('g', 'help', value=1)) self.assertEqual(1, self.registry.get_sample_value('g', {})) def test_gauge_labels(self): cmf = GaugeMetricFamily('g', 'help', labels=['a']) cmf.add_metric(['b'], 2) self.custom_collector(cmf) self.assertEqual(2, self.registry.get_sample_value('g', {'a': 'b'})) def test_summary(self): self.custom_collector( SummaryMetricFamily('s', 'help', count_value=1, sum_value=2)) self.assertEqual(1, self.registry.get_sample_value('s_count', {})) self.assertEqual(2, self.registry.get_sample_value('s_sum', {})) def test_summary_labels(self): cmf = SummaryMetricFamily('s', 'help', labels=['a']) cmf.add_metric(['b'], count_value=1, sum_value=2) self.custom_collector(cmf) self.assertEqual(1, self.registry.get_sample_value('s_count', {'a': 'b'})) self.assertEqual(2, self.registry.get_sample_value('s_sum', {'a': 'b'})) def test_histogram(self): self.custom_collector( HistogramMetricFamily('h', 'help', buckets=[('0', 1), ('+Inf', 2)], sum_value=3)) self.assertEqual( 1, self.registry.get_sample_value('h_bucket', {'le': '0'})) self.assertEqual( 2, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) self.assertEqual(2, self.registry.get_sample_value('h_count', {})) self.assertEqual(3, self.registry.get_sample_value('h_sum', {})) def test_histogram_labels(self): cmf = HistogramMetricFamily('h', 'help', labels=['a']) cmf.add_metric(['b'], buckets=[('0', 1), ('+Inf', 2)], sum_value=3) self.custom_collector(cmf) self.assertEqual( 1, self.registry.get_sample_value('h_bucket', { 'a': 'b', 'le': '0' })) self.assertEqual( 2, self.registry.get_sample_value('h_bucket', { 'a': 'b', 'le': '+Inf' })) self.assertEqual(2, self.registry.get_sample_value('h_count', {'a': 'b'})) self.assertEqual(3, self.registry.get_sample_value('h_sum', {'a': 'b'})) def test_gaugehistogram(self): self.custom_collector( GaugeHistogramMetricFamily('h', 'help', buckets=[('0', 1), ('+Inf', 2)])) self.assertEqual( 1, self.registry.get_sample_value('h_bucket', {'le': '0'})) self.assertEqual( 2, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) def test_gaugehistogram_labels(self): cmf = GaugeHistogramMetricFamily('h', 'help', labels=['a']) cmf.add_metric(['b'], buckets=[('0', 1), ('+Inf', 2)], gsum_value=3) self.custom_collector(cmf) self.assertEqual( 1, self.registry.get_sample_value('h_bucket', { 'a': 'b', 'le': '0' })) self.assertEqual( 2, self.registry.get_sample_value('h_bucket', { 'a': 'b', 'le': '+Inf' })) self.assertEqual( 2, self.registry.get_sample_value('h_gcount', {'a': 'b'})) self.assertEqual(3, self.registry.get_sample_value('h_gsum', {'a': 'b'})) def test_info(self): self.custom_collector(InfoMetricFamily('i', 'help', value={'a': 'b'})) self.assertEqual(1, self.registry.get_sample_value('i_info', {'a': 'b'})) def test_info_labels(self): cmf = InfoMetricFamily('i', 'help', labels=['a']) cmf.add_metric(['b'], {'c': 'd'}) self.custom_collector(cmf) self.assertEqual( 1, self.registry.get_sample_value('i_info', { 'a': 'b', 'c': 'd' })) def test_stateset(self): self.custom_collector( StateSetMetricFamily('s', 'help', value={ 'a': True, 'b': True, })) self.assertEqual(1, self.registry.get_sample_value('s', {'s': 'a'})) self.assertEqual(1, self.registry.get_sample_value('s', {'s': 'b'})) def test_stateset_labels(self): cmf = StateSetMetricFamily('s', 'help', labels=['foo']) cmf.add_metric(['bar'], { 'a': False, 'b': False, }) self.custom_collector(cmf) self.assertEqual( 0, self.registry.get_sample_value('s', { 'foo': 'bar', 's': 'a' })) self.assertEqual( 0, self.registry.get_sample_value('s', { 'foo': 'bar', 's': 'b' })) def test_bad_constructors(self): self.assertRaises(ValueError, UntypedMetricFamily, 'u', 'help', value=1, labels=[]) self.assertRaises(ValueError, UntypedMetricFamily, 'u', 'help', value=1, labels=['a']) self.assertRaises(ValueError, CounterMetricFamily, 'c_total', 'help', value=1, labels=[]) self.assertRaises(ValueError, CounterMetricFamily, 'c_total', 'help', value=1, labels=['a']) self.assertRaises(ValueError, GaugeMetricFamily, 'g', 'help', value=1, labels=[]) self.assertRaises(ValueError, GaugeMetricFamily, 'g', 'help', value=1, labels=['a']) self.assertRaises(ValueError, SummaryMetricFamily, 's', 'help', sum_value=1) self.assertRaises(ValueError, SummaryMetricFamily, 's', 'help', count_value=1) self.assertRaises(ValueError, SummaryMetricFamily, 's', 'help', count_value=1, labels=['a']) self.assertRaises(ValueError, SummaryMetricFamily, 's', 'help', sum_value=1, labels=['a']) self.assertRaises(ValueError, SummaryMetricFamily, 's', 'help', count_value=1, sum_value=1, labels=['a']) self.assertRaises(ValueError, HistogramMetricFamily, 'h', 'help', sum_value=1) self.assertRaises(KeyError, HistogramMetricFamily, 'h', 'help', buckets={}) self.assertRaises(ValueError, HistogramMetricFamily, 'h', 'help', sum_value=1, labels=['a']) self.assertRaises(ValueError, HistogramMetricFamily, 'h', 'help', buckets={}, labels=['a']) self.assertRaises(ValueError, HistogramMetricFamily, 'h', 'help', buckets={}, sum_value=1, labels=['a']) self.assertRaises(KeyError, HistogramMetricFamily, 'h', 'help', buckets={}, sum_value=1) self.assertRaises(ValueError, InfoMetricFamily, 'i', 'help', value={}, labels=[]) self.assertRaises(ValueError, InfoMetricFamily, 'i', 'help', value={}, labels=['a']) self.assertRaises(ValueError, StateSetMetricFamily, 's', 'help', value={'a': True}, labels=[]) self.assertRaises(ValueError, StateSetMetricFamily, 's', 'help', value={'a': True}, labels=['a']) def test_labelnames(self): cmf = UntypedMetricFamily('u', 'help', labels=iter(['a'])) self.assertEqual(('a', ), cmf._labelnames) cmf = CounterMetricFamily('c_total', 'help', labels=iter(['a'])) self.assertEqual(('a', ), cmf._labelnames) gmf = GaugeMetricFamily('g', 'help', labels=iter(['a'])) self.assertEqual(('a', ), gmf._labelnames) smf = SummaryMetricFamily('s', 'help', labels=iter(['a'])) self.assertEqual(('a', ), smf._labelnames) hmf = HistogramMetricFamily('h', 'help', labels=iter(['a'])) self.assertEqual(('a', ), hmf._labelnames)
def setUp(self): self.tempdir = tempfile.mkdtemp() os.environ['PROMETHEUS_MULTIPROC_DIR'] = self.tempdir values.ValueClass = MultiProcessValue(lambda: 123) self.registry = CollectorRegistry() self.collector = MultiProcessCollector(self.registry)
def test_roundtrip(self): text = """# HELP go_gc_duration_seconds A summary of the GC invocation durations. # TYPE go_gc_duration_seconds summary go_gc_duration_seconds{quantile="0.0"} 0.013300656000000001 go_gc_duration_seconds{quantile="0.25"} 0.013638736 go_gc_duration_seconds{quantile="0.5"} 0.013759906 go_gc_duration_seconds{quantile="0.75"} 0.013962066 go_gc_duration_seconds{quantile="1.0"} 0.021383540000000003 go_gc_duration_seconds_sum 56.12904785 go_gc_duration_seconds_count 7476.0 # HELP go_goroutines Number of goroutines that currently exist. # TYPE go_goroutines gauge go_goroutines 166.0 # HELP prometheus_local_storage_indexing_batch_duration_milliseconds Quantiles for batch indexing duration in milliseconds. # TYPE prometheus_local_storage_indexing_batch_duration_milliseconds summary prometheus_local_storage_indexing_batch_duration_milliseconds{quantile="0.5"} NaN prometheus_local_storage_indexing_batch_duration_milliseconds{quantile="0.9"} NaN prometheus_local_storage_indexing_batch_duration_milliseconds{quantile="0.99"} NaN prometheus_local_storage_indexing_batch_duration_milliseconds_sum 871.5665949999999 prometheus_local_storage_indexing_batch_duration_milliseconds_count 229.0 # HELP process_cpu_seconds Total user and system CPU time spent in seconds. # TYPE process_cpu_seconds counter process_cpu_seconds_total 29323.4 # HELP process_virtual_memory_bytes Virtual memory size in bytes. # TYPE process_virtual_memory_bytes gauge process_virtual_memory_bytes 2.478268416e+09 # HELP prometheus_build_info A metric with a constant '1' value labeled by version, revision, and branch from which Prometheus was built. # TYPE prometheus_build_info gauge prometheus_build_info{branch="HEAD",revision="ef176e5",version="0.16.0rc1"} 1.0 # HELP prometheus_local_storage_chunk_ops The total number of chunk operations by their type. # TYPE prometheus_local_storage_chunk_ops counter prometheus_local_storage_chunk_ops_total{type="clone"} 28.0 prometheus_local_storage_chunk_ops_total{type="create"} 997844.0 prometheus_local_storage_chunk_ops_total{type="drop"} 1.345758e+06 prometheus_local_storage_chunk_ops_total{type="load"} 1641.0 prometheus_local_storage_chunk_ops_total{type="persist"} 981408.0 prometheus_local_storage_chunk_ops_total{type="pin"} 32662.0 prometheus_local_storage_chunk_ops_total{type="transcode"} 980180.0 prometheus_local_storage_chunk_ops_total{type="unpin"} 32662.0 # HELP foo histogram Testing histogram buckets # TYPE foo histogram foo_bucket{le="0.0"} 0.0 foo_bucket{le="1e-05"} 0.0 foo_bucket{le="0.0001"} 0.0 foo_bucket{le="0.1"} 8.0 foo_bucket{le="1.0"} 10.0 foo_bucket{le="10.0"} 17.0 foo_bucket{le="100000.0"} 17.0 foo_bucket{le="1e+06"} 17.0 foo_bucket{le="1.55555555555552e+06"} 17.0 foo_bucket{le="1e+23"} 17.0 foo_bucket{le="+Inf"} 17.0 foo_count 17.0 foo_sum 324789.3 foo_created 1.520430000123e+09 # EOF """ families = list(text_string_to_metric_families(text)) class TextCollector(object): def collect(self): return families registry = CollectorRegistry() registry.register(TextCollector()) self.assertEqual(text.encode('utf-8'), generate_latest(registry))
def __init__(self): self.loop = asyncio.get_event_loop() self.registry = CollectorRegistry( ) # 存放所有Metrics的容器,以Name-Metric(Key-Value)形式维护其中的Metric对象。 self.all_metric = {}
def setUp(self): self.registry = CollectorRegistry() self.gauge = Gauge('g', 'help', registry=self.registry)
requests_total = Counter("request_count", "Total request cout of the host") # 如果只返回一个metrics @app.route("/metrics") def requests_count(): requests_total.inc() # requests_total.inc(2) return Response(prometheus_client.generate_latest(requests_total), mimetype="text/plain") # 如果返回多个metrics #### 定义一个仓库,存放数据 REGISTRY = CollectorRegistry(auto_describe=False) muxStatus = Gauge("mux_api_21", "Api response stats is:", registry=REGISTRY) manageStatus = Gauge("manage_api_21", "Api response stats is:", registry=REGISTRY) #### 定义路由 @app.route("/metrics") def ApiResponse(): muxStatus.set(muxCode) manageStatus.set(manageCode) return Response(prometheus_client.generate_latest(REGISTRY), mimetype="text/plain")
def test_target_info_injected(self): registry = CollectorRegistry(target_info={'foo': 'bar'}) self.assertEqual( 1, registry.get_sample_value('target_info', {'foo': 'bar'}))
class TestHistogram(unittest.TestCase): def setUp(self): self.registry = CollectorRegistry() self.histogram = Histogram('h', 'help', registry=self.registry) self.labels = Histogram('hl', 'help', ['l'], registry=self.registry) def test_repr(self): self.assertEqual(repr(self.histogram), "prometheus_client.metrics.Histogram(h)") self.assertEqual(repr(self.labels), "prometheus_client.metrics.Histogram(hl)") def test_histogram(self): self.assertEqual( 0, self.registry.get_sample_value('h_bucket', {'le': '1.0'})) self.assertEqual( 0, self.registry.get_sample_value('h_bucket', {'le': '2.5'})) self.assertEqual( 0, self.registry.get_sample_value('h_bucket', {'le': '5.0'})) self.assertEqual( 0, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) self.assertEqual(0, self.registry.get_sample_value('h_count')) self.assertEqual(0, self.registry.get_sample_value('h_sum')) self.histogram.observe(2) self.assertEqual( 0, self.registry.get_sample_value('h_bucket', {'le': '1.0'})) self.assertEqual( 1, self.registry.get_sample_value('h_bucket', {'le': '2.5'})) self.assertEqual( 1, self.registry.get_sample_value('h_bucket', {'le': '5.0'})) self.assertEqual( 1, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) self.assertEqual(1, self.registry.get_sample_value('h_count')) self.assertEqual(2, self.registry.get_sample_value('h_sum')) self.histogram.observe(2.5) self.assertEqual( 0, self.registry.get_sample_value('h_bucket', {'le': '1.0'})) self.assertEqual( 2, self.registry.get_sample_value('h_bucket', {'le': '2.5'})) self.assertEqual( 2, self.registry.get_sample_value('h_bucket', {'le': '5.0'})) self.assertEqual( 2, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) self.assertEqual(2, self.registry.get_sample_value('h_count')) self.assertEqual(4.5, self.registry.get_sample_value('h_sum')) self.histogram.observe(float("inf")) self.assertEqual( 0, self.registry.get_sample_value('h_bucket', {'le': '1.0'})) self.assertEqual( 2, self.registry.get_sample_value('h_bucket', {'le': '2.5'})) self.assertEqual( 2, self.registry.get_sample_value('h_bucket', {'le': '5.0'})) self.assertEqual( 3, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) self.assertEqual(3, self.registry.get_sample_value('h_count')) self.assertEqual(float("inf"), self.registry.get_sample_value('h_sum')) def test_setting_buckets(self): h = Histogram('h', 'help', registry=None, buckets=[0, 1, 2]) self.assertEqual([0.0, 1.0, 2.0, float("inf")], h._upper_bounds) h = Histogram('h', 'help', registry=None, buckets=[0, 1, 2, float("inf")]) self.assertEqual([0.0, 1.0, 2.0, float("inf")], h._upper_bounds) self.assertRaises(ValueError, Histogram, 'h', 'help', registry=None, buckets=[]) self.assertRaises(ValueError, Histogram, 'h', 'help', registry=None, buckets=[float("inf")]) self.assertRaises(ValueError, Histogram, 'h', 'help', registry=None, buckets=[3, 1]) def test_labels(self): self.assertRaises(ValueError, Histogram, 'h', 'help', registry=None, labelnames=['le']) self.labels.labels('a').observe(2) self.assertEqual( 0, self.registry.get_sample_value('hl_bucket', { 'le': '1.0', 'l': 'a' })) self.assertEqual( 1, self.registry.get_sample_value('hl_bucket', { 'le': '2.5', 'l': 'a' })) self.assertEqual( 1, self.registry.get_sample_value('hl_bucket', { 'le': '5.0', 'l': 'a' })) self.assertEqual( 1, self.registry.get_sample_value('hl_bucket', { 'le': '+Inf', 'l': 'a' })) self.assertEqual( 1, self.registry.get_sample_value('hl_count', {'l': 'a'})) self.assertEqual(2, self.registry.get_sample_value('hl_sum', {'l': 'a'})) def test_function_decorator(self): self.assertEqual(0, self.registry.get_sample_value('h_count')) self.assertEqual( 0, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) @self.histogram.time() def f(): pass self.assertEqual(([], None, None, None), inspect.getargspec(f)) f() self.assertEqual(1, self.registry.get_sample_value('h_count')) self.assertEqual( 1, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) def test_function_decorator_multithread(self): self.assertEqual(0, self.registry.get_sample_value('h_count')) workers = 3 duration = 0.1 pool = ThreadPoolExecutor(max_workers=workers) @self.histogram.time() def f(): time.sleep(duration) jobs = workers * 3 for i in range(jobs): pool.submit(f) pool.shutdown(wait=True) self.assertEqual(jobs, self.registry.get_sample_value('h_count')) rounding_coefficient = 0.9 total_expected_duration = jobs * duration * rounding_coefficient self.assertLess(total_expected_duration, self.registry.get_sample_value('h_sum')) def test_block_decorator(self): self.assertEqual(0, self.registry.get_sample_value('h_count')) self.assertEqual( 0, self.registry.get_sample_value('h_bucket', {'le': '+Inf'})) with self.histogram.time(): pass self.assertEqual(1, self.registry.get_sample_value('h_count')) self.assertEqual( 1, self.registry.get_sample_value('h_bucket', {'le': '+Inf'}))
def setUp(self): self.registry = CollectorRegistry() self.summary = Summary('s', 'help', registry=self.registry)
class TestMetricWrapper(unittest.TestCase): def setUp(self): self.registry = CollectorRegistry() self.counter = Counter('c', 'help', labelnames=['l'], registry=self.registry) self.two_labels = Counter('two', 'help', labelnames=['a', 'b'], registry=self.registry) def test_child(self): self.counter.labels('x').inc() self.assertEqual(1, self.registry.get_sample_value('c', {'l': 'x'})) self.two_labels.labels('x', 'y').inc(2) self.assertEqual( 2, self.registry.get_sample_value('two', { 'a': 'x', 'b': 'y' })) def test_remove(self): self.counter.labels('x').inc() self.counter.labels('y').inc(2) self.assertEqual(1, self.registry.get_sample_value('c', {'l': 'x'})) self.assertEqual(2, self.registry.get_sample_value('c', {'l': 'y'})) self.counter.remove('x') self.assertEqual(None, self.registry.get_sample_value('c', {'l': 'x'})) self.assertEqual(2, self.registry.get_sample_value('c', {'l': 'y'})) def test_incorrect_label_count_raises(self): self.assertRaises(ValueError, self.counter.labels) self.assertRaises(ValueError, self.counter.labels, 'a', 'b') self.assertRaises(ValueError, self.counter.remove) self.assertRaises(ValueError, self.counter.remove, 'a', 'b') def test_labels_coerced_to_string(self): self.counter.labels(None).inc() self.counter.labels(l=None).inc() self.assertEqual(2, self.registry.get_sample_value('c', {'l': 'None'})) self.counter.remove(None) self.assertEqual(None, self.registry.get_sample_value('c', {'l': 'None'})) def test_non_string_labels_raises(self): class Test(object): __str__ = None self.assertRaises(TypeError, self.counter.labels, Test()) self.assertRaises(TypeError, self.counter.labels, l=Test()) def test_namespace_subsystem_concatenated(self): c = Counter('c', 'help', namespace='a', subsystem='b', registry=self.registry) c.inc() self.assertEqual(1, self.registry.get_sample_value('a_b_c')) def test_labels_by_kwarg(self): self.counter.labels(l='x').inc() self.assertEqual(1, self.registry.get_sample_value('c', {'l': 'x'})) self.assertRaises(ValueError, self.counter.labels, l='x', m='y') self.assertRaises(ValueError, self.counter.labels, m='y') self.assertRaises(ValueError, self.counter.labels) self.two_labels.labels(a='x', b='y').inc() self.assertEqual( 1, self.registry.get_sample_value('two', { 'a': 'x', 'b': 'y' })) self.assertRaises(ValueError, self.two_labels.labels, a='x', b='y', c='z') self.assertRaises(ValueError, self.two_labels.labels, a='x', c='z') self.assertRaises(ValueError, self.two_labels.labels, b='y', c='z') self.assertRaises(ValueError, self.two_labels.labels, c='z') self.assertRaises(ValueError, self.two_labels.labels) self.assertRaises(ValueError, self.two_labels.labels, {'a': 'x'}, b='y') def test_invalid_names_raise(self): self.assertRaises(ValueError, Counter, '', 'help') self.assertRaises(ValueError, Counter, '^', 'help') self.assertRaises(ValueError, Counter, '', 'help', namespace='&') self.assertRaises(ValueError, Counter, '', 'help', subsystem='(') self.assertRaises(ValueError, Counter, 'c', '', labelnames=['^']) self.assertRaises(ValueError, Counter, 'c', '', labelnames=['a:b']) self.assertRaises(ValueError, Counter, 'c', '', labelnames=['__reserved']) self.assertRaises(ValueError, Summary, 'c', '', labelnames=['quantile']) def test_empty_labels_list(self): Histogram('h', 'help', [], registry=self.registry) self.assertEqual(0, self.registry.get_sample_value('h_sum')) def test_wrapped_original_class(self): self.assertEqual(Counter.__wrapped__, Counter('foo', 'bar').__class__)