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