def test_batch_send(mock_post):
"""
Test that when we create more than BATCH_SIZE number of points
we are able to send all of them
"""
mock_post.return_value.status_code = 204
token = "asdashdsauh_8aeraerf"
tags = {
"host": "localhost",
"region": "us-east-1",
"service": "web-server"
}
registry = MetricsRegistry()
reporter = ApptuitReporter(sanitize_mode=None,
registry=registry,
api_endpoint="http://localhost",
reporting_interval=1,
token=token,
prefix="apr.",
tags=tags)
points_to_be_created = BATCH_SIZE * 2 + 10
counters = [
registry.counter("counter%d" % i) for i in range(points_to_be_created)
]
for i in range(points_to_be_created):
counters[i].inc()
reporter.report_now()
total_points_sent = reporter._meta_metrics_registry.counter(
NUMBER_OF_TOTAL_POINTS).get_count()
assert_equals(total_points_sent, points_to_be_created)
def test_collect_data_points():
"""
Test data is being collected correctly
"""
token = "asdashdsauh_8aeraerf"
tags = {
"host": "localhost",
"region": "us-east-1",
"service": "web-server"
}
registry = MetricsRegistry()
reporter = ApptuitReporter(sanitize_mode=None,
registry=registry,
api_endpoint="http://localhost",
reporting_interval=1,
token=token,
prefix="apr.",
tags=tags)
counter_test = registry.counter('counter {"tk1":"tv1","tk2":"tv2"}')
counter_test.inc(2)
dps = reporter._collect_data_points(reporter.registry)
assert_equals(len(dps), 1)
assert_equals(dps[0].value, 2)
assert_equals(dps[0].metric, "apr.counter.count")
assert_equals(
dps[0].tags, {
'host': 'localhost',
'region': 'us-east-1',
'service': 'web-server',
'tk1': 'tv1',
'tk2': 'tv2'
})
def test_send_negative(mock_post):
"""
Test negative responce from Apptuit backend
"""
mock_post.return_value.status_code = 503
token = "asdashdsauh_8aeraerf"
tags = {
"host": "localhost",
"region": "us-east-1",
"service": "web-server"
}
registry = MetricsRegistry()
reporter = ApptuitReporter(sanitize_mode=None,
registry=registry,
api_endpoint="http://localhost",
reporting_interval=1,
token=token,
prefix="apr.",
tags=tags)
cput = registry.histogram("cpu")
count = 0
while True:
cput.add(random.randint(1, 100))
count = count + 1
if count > 10000:
break
with assert_raises(ApptuitSendException):
reporter.report_now()
def test_reporter_thread_active(mock_post):
"""
Test that reporter thread is active even if we are not able to send data
"""
mock_post.return_value.status_code = 503
mock_post.side_effect = HTTPError()
token = "asdashdsauh_8aeraerf"
tags = {
"host": "localhost",
"region": "us-east-1",
"service": "web-server"
}
registry = MetricsRegistry()
reporter = ApptuitReporter(sanitize_mode=None,
registry=registry,
api_endpoint="http://localhost",
reporting_interval=1,
token=token,
prefix="apr.",
tags=tags)
reporter.start()
cput = registry.histogram("cpu")
cput.add(random.randint(1, 100))
time.sleep(3)
assert_greater_equal(mock_post.call_count, 2)
def __init__(self,
host,
port,
global_key,
worker_name,
metrics_name,
logger,
enabled=True):
self._logger = logger
try:
self.enabled = enabled
if self.enabled:
self.hostname = socket.gethostname().split('.')[0]
self.registry = MetricsRegistry()
self.global_key = global_key + '.' + self.hostname + '.' + worker_name + '.'
self.reporter = CarbonReporter(registry=self.registry,
reporting_interval=1,
prefix=self.global_key,
server=host,
port=port)
self.reporter.start()
self.after_init(host, port, global_key, worker_name, metrics_name,
enabled)
except Exception as e:
self._logger.error('GraphiteSender exception: {}'.format(e))
self._logger.error('GraphiteSender traceback: {}'.format(
traceback.format_exc()))
def test_globaltags_none():
"""
Test that metric tags work when global tags are not present
"""
host = socket.gethostname()
token = "asdashdsauh_8aeraerf"
tags = {"region": "us-east-1"}
registry = MetricsRegistry()
reporter = ApptuitReporter(sanitize_mode=None,
registry=registry,
api_endpoint="http://localhost",
reporting_interval=1,
token=token,
tags=None)
counter1 = registry.counter('counter1 {"region":"us-west-2","id": 1}')
counter2 = registry.counter(
'counter2 {"region":"us-west-3","id": 2, "new_tag": "foo"}')
counter1.inc(2)
counter2.inc()
dps = reporter._collect_data_points(reporter.registry)
dps = sorted(dps, key=lambda x: x.metric)
assert_equals(len(dps), 2)
assert_equals(dps[0].tags, {"region": "us-west-2", "id": 1, "host": host})
assert_equals(dps[1].tags, {
"region": "us-west-3",
"id": 2,
"new_tag": "foo",
"host": host
})
assert_equals(reporter.tags, {"host": host})
def test_globaltags_override():
"""
Test that if the global tags and metric tags contain same tag key,
the metric tags override global tags
"""
host = socket.gethostname()
token = "asdashdsauh_8aeraerf"
tags = {"region": "us-east-1"}
registry = MetricsRegistry()
reporter = ApptuitReporter(sanitize_mode=None,
registry=registry,
api_endpoint="http://localhost",
reporting_interval=1,
token=token,
tags=tags)
counter1 = registry.counter('counter1 {"region":"us-west-2","id": 1}')
counter2 = registry.counter(
'counter2 {"region":"us-west-3","id": 2, "new_tag": "foo"}')
counter3 = registry.counter('counter3')
counter1.inc(2)
counter2.inc()
counter3.inc()
dps = reporter._collect_data_points(reporter.registry)
dps = sorted(dps, key=lambda x: x.metric)
assert_equals(dps[0].tags, {"region": "us-west-2", "id": 1, "host": host})
assert_equals(dps[1].tags, {
"region": "us-west-3",
"id": 2,
"new_tag": "foo",
"host": host
})
assert_equals(dps[2].tags, {"region": "us-east-1", "host": host})
assert_equals(reporter.tags, {"region": "us-east-1", "host": host})
def test_process_metrics_of_reporter_is_active(mock_post):
"""
Test that process metrics of reporter is active
"""
mock_post.return_value.status_code = 200
token = "asdashdsauh_8aeraerf"
tags = {
"host": "localhost",
"region": "us-east-1",
"service": "web-server"
}
registry = MetricsRegistry()
reporter = ApptuitReporter(sanitize_mode=None,
registry=registry,
api_endpoint="http://localhost",
reporting_interval=1,
token=token,
tags=tags,
collect_process_metrics=True)
reporter.report_now()
for i in reporter.process_metrics.resource_metric_names:
assert_in(i, registry._counters)
for i in reporter.process_metrics.thread_metrics_names:
assert_in(i, registry._gauges)
for i in reporter.process_metrics.gc_metric_names:
assert_in(i, registry._counters)
def test_meta_metrics_of_reporter(mock_post):
"""
Test that meta metrics of reporter work
"""
mock_post.return_value.status_code = 200
token = "asdashdsauh_8aeraerf"
registry = MetricsRegistry()
reporter = ApptuitReporter(sanitize_mode=None,
registry=registry,
api_endpoint="http://localhost",
reporting_interval=1,
token=token,
tags=None)
cput = registry.counter("cpu.time")
cput.inc(1)
dps = reporter._collect_data_points(reporter.registry)
assert_equals(len(dps), 1)
assert_equals(dps[0].metric, "cpu.time.count")
assert_equals(dps[0].value, 1)
reporter.report_now()
dps = reporter._collect_data_points(reporter._meta_metrics_registry)
dps = sorted(dps, key=lambda x: x.metric)
assert_equals(len(dps), 18)
assert_equals(dps[0].metric, "apptuit.reporter.send.failed.count")
assert_equals(dps[1].metric, "apptuit.reporter.send.successful.count")
assert_equals(dps[11].metric, "apptuit.reporter.send.time.count")
assert_equals(dps[17].metric, "apptuit.reporter.send.total.count")
def test_delta_reset(self):
reg = MetricsRegistry()
counter = delta.delta_counter(reg, "foo_delta_1")
counter.inc(10)
wf_reporter = get_base_reporter(reg)
wf_reporter._collect_metrics(reg)
assert (counter.get_count() == 0) # delta decremented by count
def test_reporter_tags_with_global_env_tags():
"""
Test that reporter tags take priority
TODO:
We have 8 possible combinations -
1. global env tags: true, reporter tags: true, metric tags: true
2. global env tags: true, reporter tags: true, metric tags: false
3. global env tags: true, reporter tags: false, metric tags: true
4. global env tags: true, reporter tags: false, metric tags: false
5. global env tags: false, reporter tags: true, metric tags: true
6. global env tags: false, reporter tags: true, metric tags: false
7. global env tags: false, reporter tags: false, metric tags: true
8. global env tags: false, reporter tags: false, metric tags: false
"""
mock_environ = patch.dict(os.environ, {APPTUIT_PY_TOKEN: "environ_token",
APPTUIT_PY_TAGS: 'host: environ, ip: 1.1.1.1'})
mock_environ.start()
registry = MetricsRegistry()
reporter = ApptuitReporter(registry=registry, tags={"host": "reporter", "ip": "2.2.2.2"})
counter = registry.counter("counter")
counter.inc(1)
payload = reporter.client._create_payload_from_datapoints(reporter._collect_data_points(reporter.registry))
assert_equals(len(payload), 1)
assert_equals(payload[0]["tags"], {'host': 'reporter', 'ip': '2.2.2.2'})
reporter = ApptuitReporter(registry=registry)
counter = registry.counter("counter")
counter.inc(1)
payload = reporter.client._create_payload_from_datapoints(reporter._collect_data_points(reporter.registry))
assert_equals(len(payload), 1)
assert_equals(payload[0]["tags"], {"host": "environ", "ip": "1.1.1.1"})
mock_environ.stop()
def test_no_environ_tags():
"""
Test tags work even if no global tags present as env variable
"""
timestamp = int(time.time())
test_val = math.pi
mock_environ = patch.dict(os.environ, {APPTUIT_PY_TOKEN: "environ_token"})
mock_environ.start()
client = Apptuit()
dp1 = DataPoint(metric="test_metric", tags={"host": "host2", "ip": "2.2.2.2", "test": 1},
timestamp=timestamp, value=test_val)
dp2 = DataPoint(metric="test_metric", tags={"test": 2}, timestamp=timestamp, value=test_val)
payload = client._create_payload_from_datapoints([dp1, dp2])
assert_equals(len(payload), 2)
assert_equals(payload[0]["tags"], {"host": "host2", "ip": "2.2.2.2", "test": 1})
assert_equals(payload[1]["tags"], {"test": 2})
registry = MetricsRegistry()
reporter = ApptuitReporter(registry=registry, tags={"host": "reporter", "ip": "2.2.2.2"})
counter = registry.counter("counter")
counter.inc(1)
payload = reporter.client._create_payload_from_datapoints(reporter._collect_data_points(reporter.registry))
assert_equals(len(payload), 1)
assert_equals(payload[0]["tags"], {'host': 'reporter', 'ip': '2.2.2.2'})
mock_environ.stop()
def __init__(self,
privkey: keys.PrivateKey,
context: BasePeerContext,
max_peers: int = DEFAULT_MAX_PEERS,
event_bus: EndpointAPI = None,
metrics_registry: MetricsRegistry = None,
) -> None:
self.logger = get_logger(self.__module__ + '.' + self.__class__.__name__)
self.privkey = privkey
self.max_peers = max_peers
self.context = context
self.connected_nodes: Dict[SessionAPI, BasePeer] = {}
self._subscribers: List[PeerSubscriber] = []
self._event_bus = event_bus
if metrics_registry is None:
# Initialize with a MetricsRegistry from pyformance as p2p can not depend on Trinity
# This is so that we don't need to pass a MetricsRegistry in tests and mocked pools.
metrics_registry = MetricsRegistry()
self._active_peer_counter = metrics_registry.counter('trinity.p2p/peers.counter')
self._peer_reporter_registry = self.get_peer_reporter_registry(metrics_registry)
# Restricts the number of concurrent connection attempts can be made
self._connection_attempt_lock = asyncio.BoundedSemaphore(MAX_CONCURRENT_CONNECTION_ATTEMPTS)
# Ensure we can only have a single concurrent handshake in flight per remote
self._handshake_locks = ResourceLock()
self.peer_backends = self.setup_peer_backends()
self.connection_tracker = self.setup_connection_tracker()
def test_apptuit_sanitizer_of_reporter(mock_post):
"""
Test that apptuit_sanitizer of reporter works
"""
mock_post.return_value.status_code = 200
token = "asdashdsauh_8aeraerf"
tags = {
"host": "localhost",
u"region-loc$-本語": u"us-east-1-本語",
"service.type/name": "web-server"
}
registry = MetricsRegistry()
reporter = ApptuitReporter(
sanitize_mode="apptuit",
registry=registry,
api_endpoint="http://localhost",
reporting_interval=1,
token=token,
tags=tags,
)
assert_equals(reporter.client.sanitizer, sanitize_name_apptuit)
unicode_counter = registry.counter(u'abc.日本語')
unicode_counter.inc(1)
dps = reporter._collect_data_points(reporter.registry)
payload = reporter.client._create_payload_from_datapoints(dps)
assert_equals(payload[0]['metric'], u'abc.日本語.count')
assert_equals(
payload[0]['tags'], {
"host": "localhost",
u"region-loc_-本語": u"us-east-1-本語",
"service.type/name": "web-server"
})
assert_equals(payload[0]['value'], 1)
registry.clear()
cput = registry.counter('7&&cpu-time/seconds{"total-%": "100"}')
cput.inc(1)
dps = reporter._collect_data_points(reporter.registry)
payload = reporter.client._create_payload_from_datapoints(dps)
assert_equals(len(payload), 1)
assert_equals(payload[0]['metric'], "7_cpu-time/seconds.count")
assert_equals(
payload[0]['tags'], {
'host': 'localhost',
u'region-loc_-本語': u'us-east-1-本語',
'service.type/name': 'web-server',
'total-_': '100'
})
assert_equals(payload[0]['value'], 1)
reporter.report_now()
dps = reporter._collect_data_points(reporter._meta_metrics_registry)
payload = reporter.client._create_payload_from_datapoints(dps)
assert_equals(len(payload), 18)
payload = sorted(payload, key=lambda x: x['metric'])
assert_equals(payload[0]['metric'], "apptuit.reporter.send.failed.count")
assert_equals(payload[1]['metric'],
"apptuit.reporter.send.successful.count")
assert_equals(payload[11]['metric'], "apptuit.reporter.send.time.count")
assert_equals(payload[17]['metric'], "apptuit.reporter.send.total.count")
def wavefront_wrapper(*args, **kwargs):
log.debug("WaveFrontWrapper: starting")
server = os.environ.get('WAVEFRONT_URL')
if not server:
raise ValueError("Environment variable WAVEFRONT_URL is not set.")
auth_token = os.environ.get('WAVEFRONT_API_TOKEN')
if not auth_token:
raise ValueError(
"Environment variable WAVEFRONT_API_TOKEN is not set.")
is_report_standard_metrics = True
if os.environ.get('REPORT_STANDARD_METRICS') in ['False', 'false']:
is_report_standard_metrics = False
# AWS lambda execution enviroment requires handler to consume two arguments
# 1. Event - input of json format
# 2. Context - The execution context object
context = args[1]
# Expected formats for Lambda ARN are:
# https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-lambda
invoked_function_arn = context.invoked_function_arn
split_arn = invoked_function_arn.split(':')
point_tags = {
'LambdaArn': invoked_function_arn,
'FunctionName': context.function_name,
'ExecutedVersion': context.function_version,
'Region': split_arn[3],
'accountId': split_arn[4]
}
if split_arn[5] == 'function':
point_tags['Resource'] = split_arn[6]
if len(split_arn) == 8:
point_tags[
'Resource'] = point_tags['Resource'] + ":" + split_arn[7]
elif split_arn[5] == 'event-source-mappings':
point_tags['EventSourceMappings'] = split_arn[6]
log.debug("WaveFrontWrapper: starting registry")
# Initialize registry for each lambda invocation
global reg
reg = MetricsRegistry()
if reg is None:
log.error("WaveFrontWrapper: failed to start registry")
# Initialize the wavefront direct reporter
wf_direct_reporter = WavefrontDirectReporter(
server=server,
token=auth_token,
registry=reg,
source=point_tags['FunctionName'],
tags=point_tags,
prefix="")
if is_report_standard_metrics:
return call_lambda_with_standard_metrics(wf_direct_reporter, *args,
**kwargs)
else:
return call_lambda_without_standard_metrics(
wf_direct_reporter, *args, **kwargs)
def test_no_token():
"""
Test that no token raises error
"""
registry = MetricsRegistry()
with assert_raises(ValueError) as ex:
ApptuitReporter(sanitize_mode=None,
registry=registry,
reporting_interval=1,
prefix="apr.")
def report_metrics(host, server, token):
reg = MetricsRegistry()
wf_proxy_reporter = WavefrontProxyReporter(
host=host,
port=2878,
registry=reg,
source="wavefront-pyformance-example",
tags={
"key1": "val1",
"key2": "val2"
},
prefix="python.proxy.")
wf_direct_reporter = WavefrontDirectReporter(
server=server,
token=token,
registry=reg,
source="wavefront-pyformance-exmaple",
tags={
"key1": "val1",
"key2": "val2"
},
prefix="python.direct.")
# counter
c1 = reg.counter("foo_count")
c1.inc()
# delta counter
d1 = delta.delta_counter(reg, "foo_delta_count")
d1.inc()
d1.inc()
# gauge
g1 = reg.gauge("foo_gauge")
g1.set_value(2)
# meter
m1 = reg.meter("foo_meter")
m1.mark()
# timer
t1 = reg.timer("foo_timer")
timer_ctx = t1.time()
time.sleep(3)
timer_ctx.stop()
# histogram
h1 = reg.histogram("foo_histogram")
h1.add(1.0)
h1.add(1.5)
wf_proxy_reporter.report_now()
wf_proxy_reporter.stop()
wf_direct_reporter.report_now()
def test_deprecated_token_variable():
"""
Test that reporter and client work with the deprecated token env variable
"""
warnings.filterwarnings('error')
with patch.dict(os.environ, {DEPRECATED_APPTUIT_PY_TOKEN: "test_token"}):
registry = MetricsRegistry()
with assert_raises(DeprecationWarning):
ApptuitReporter(registry=registry,
tags={'host': 'reporter'})
warnings.resetwarnings()
def test_delta_counter(self):
reg = MetricsRegistry()
counter = delta.delta_counter(reg, "foo")
assert (isinstance(counter, delta.DeltaCounter))
# test duplicate (should return previously registered counter)
duplicate_counter = delta.delta_counter(reg, "foo")
assert (counter == duplicate_counter)
assert (delta.is_delta_counter(delta.DeltaCounter.DELTA_PREFIX + "foo",
reg))
different_counter = delta.delta_counter(reg, "foobar")
assert (counter != different_counter)
def test_time_calls_with_registry(self):
registry = MetricsRegistry()
@time_calls(registry=registry, tags={"tag1": "val1"})
def timed_func():
pass
timed_func()
stats = registry.get_metrics(key="timed_func_calls", tags={"tag1": "val1"})
print(registry.get_metrics(key="timed_func_calls", tags={"tag1": "val1"}))
self.assertEqual(stats["count"], 1)
self.assertTrue(stats["mean_rate"])
def test_collect_metrics(self):
# should return a list of point lines
reg = MetricsRegistry()
reg.counter("foo_counter_1")
reg.counter("foo_counter_2")
wf_reporter = get_base_reporter(reg)
lines = wf_reporter._collect_metrics(reg)
assert (len(lines) == 2) # equals no. of registered counters
delta.delta_counter(reg, "foo_delta_1")
delta.delta_counter(reg, "foo_delta_2")
lines = wf_reporter._collect_metrics(reg)
assert (len(lines) == 4) # added two more counters
def test_time_calls_with_registry(self):
registry = MetricsRegistry()
@time_calls(registry=registry, tags={"tag1": "val1"})
def timed_func():
pass
timed_func()
metric_name = "RegistryTestCase.test_time_calls_with_registry.<locals>.timed_func_calls"
stats = registry.get_metrics(key=metric_name, tags={"tag1": "val1"})
print(registry.get_metrics(key=metric_name, tags={"tag1": "val1"}))
self.assertEqual(stats["count"], 1)
self.assertTrue(stats["mean_rate"])
def test_tags_of_metric_take_priority():
"""
Test that metric tags take priority
"""
mock_environ = patch.dict(os.environ, {APPTUIT_PY_TOKEN: "environ_token",
APPTUIT_PY_TAGS: 'host: environ, ip: 1.1.1.1'})
mock_environ.start()
registry = MetricsRegistry()
reporter = ApptuitReporter(registry=registry, tags={"host": "reporter", "ip": "2.2.2.2"})
counter = registry.counter('counter {"host": "metric", "ip": "3.3.3.3"}')
counter.inc(1)
payload = reporter.client._create_payload_from_datapoints(reporter._collect_data_points(reporter.registry))
assert_equals(len(payload), 1)
assert_equals(payload[0]["tags"], {"host": "metric", "ip": "3.3.3.3"})
mock_environ.stop()
def test_zero_tags(mock_post):
"""
Test that using reporter without tags does not raise error
(we add host tag)
"""
mock_post.return_value.status_code = 204
token = "asdashdsauh_8aeraerf"
registry = MetricsRegistry()
reporter = ApptuitReporter(sanitize_mode=None,
registry=registry,
api_endpoint="http://localhost",
reporting_interval=1,
token=token,
prefix="apr.")
counter_test = registry.counter('counter')
counter_test.inc(2)
reporter.report_now()
def test_none_prefix():
"""
Test for None prefix
"""
token = "asdashdsauh_8aeraerf"
tags = {"region": "us-east-1"}
registry = MetricsRegistry()
reporter = ApptuitReporter(sanitize_mode=None,
registry=registry,
api_endpoint="http://localhost",
reporting_interval=1,
prefix=None,
token=token,
tags=tags)
counter1 = registry.counter('counter1')
counter1.inc()
dps = reporter._collect_data_points(reporter.registry)
assert_equals(dps[0].metric, "counter1.count")
def test_zero_tags_with_host_disabled(mock_post):
"""
Test that using reporter without tags raises error
"""
mock_post.return_value.status_code = 204
token = "asdashdsauh_8aeraerf"
registry = MetricsRegistry()
with patch.dict(os.environ, {DISABLE_HOST_TAG: "True"}):
reporter = ApptuitReporter(sanitize_mode=None,
registry=registry,
api_endpoint="http://localhost",
reporting_interval=1,
token=token,
prefix="apr.")
counter_test = registry.counter('counter')
counter_test.inc(2)
with assert_raises(ValueError):
reporter.report_now()
def test_prometheus_sanitizer_of_reporter_disabled(mock_post):
"""
Test that prometheus_sanitizer of reporter is disabled
"""
mock_post.return_value.status_code = 200
token = "asdashdsauh_8aeraerf"
tags = {
"host": "localhost",
u"region-本語": "us-east-1",
"service": "web-server"
}
registry = MetricsRegistry()
reporter = ApptuitReporter(sanitize_mode=None,
registry=registry,
api_endpoint="http://localhost",
reporting_interval=1,
token=token,
tags=tags)
unicode_counter = registry.counter(u'abc.日本語')
unicode_counter.inc(1)
dps = reporter._collect_data_points(reporter.registry)
payload = reporter.client._create_payload_from_datapoints(dps)
assert_equals(payload[0]['metric'], u'abc.日本語.count')
assert_equals(payload[0]['tags'], tags)
assert_equals(payload[0]['value'], 1)
registry.clear()
cput = registry.counter("cpu.time")
cput.inc(1)
dps = reporter._collect_data_points(reporter.registry)
payload = reporter.client._create_payload_from_datapoints(dps)
assert_equals(len(payload), 1)
assert_equals(payload[0]['metric'], "cpu.time.count")
assert_equals(payload[0]['value'], 1)
reporter.report_now()
dps = reporter._collect_data_points(reporter._meta_metrics_registry)
payload = reporter.client._create_payload_from_datapoints(dps)
payload = sorted(payload, key=lambda x: x['metric'])
assert_equals(len(dps), 18)
assert_equals(payload[0]['metric'], "apptuit.reporter.send.failed.count")
assert_equals(payload[1]['metric'],
"apptuit.reporter.send.successful.count")
assert_equals(payload[11]['metric'], "apptuit.reporter.send.time.count")
assert_equals(payload[17]['metric'], "apptuit.reporter.send.total.count")
def wavefront_wrapper(*args, **kwargs):
print("Func has been decorated.")
# Initialize registry
global reg
reg = MetricsRegistry()
# Get wavefront secrets
context, payload = args[0], args[1]
server = context["secrets"].get("wavefront_server_url", "")
auth_token = context["secrets"].get("wavefront_auth_token", "")
# Initialize the wavefront direct reporter
wf_direct_reporter = WavefrontDirectReporter(server=server,
token=auth_token,
registry=reg,
prefix="")
call_dispatch_function(wf_direct_reporter, *args, **kwargs)
def test_process_metrics_of_reporter_not_active(mock_post):
"""
Test that process metrics of reporter is not active
"""
mock_post.return_value.status_code = 200
token = "asdashdsauh_8aeraerf"
tags = {
"host": "localhost",
"region": "us-east-1",
"service": "web-server"
}
registry = MetricsRegistry()
reporter = ApptuitReporter(sanitize_mode=None,
registry=registry,
api_endpoint="http://localhost",
reporting_interval=1,
token=token,
tags=tags)
reporter.report_now()
assert_is_none(reporter.process_metrics)
def test_partially_successful_send(mock_post):
"""
Test that we handle partially successful sends
"""
mock_post.return_value.status_code = 400
mock_post.side_effect = ApptuitSendException("failed to send some points",
400,
success=98,
failed=2,
errors=[])
token = "asdashdsauh_8aeraerf"
tags = {
"host": "localhost",
"region": "us-east-1",
"service": "web-server"
}
registry = MetricsRegistry()
reporter = ApptuitReporter(sanitize_mode=None,
registry=registry,
api_endpoint="http://localhost",
reporting_interval=1,
token=token,
prefix="apr.",
tags=tags)
points_to_be_created = 100
counters = [
registry.counter("counter%d" % i) for i in range(points_to_be_created)
]
for i in range(points_to_be_created):
counters[i].inc()
with assert_raises(ApptuitSendException):
reporter.report_now()
successful_points_sent = reporter._meta_metrics_registry. \
counter(NUMBER_OF_SUCCESSFUL_POINTS).get_count()
failed_points_count = reporter._meta_metrics_registry. \
counter(NUMBER_OF_FAILED_POINTS).get_count()
assert_equals(successful_points_sent, 98)
assert_equals(failed_points_count, 2)
