def __init__(self, server, proxy=False, token=None):
if not proxy:
self._client = WavefrontDirectClient(server, token)
else:
self._client = WavefrontProxyClient(
host=server, metrics_port=2878,
distribution_port=2878, tracing_port=30000)
class WavefrontClient(object):
def __init__(self, server, proxy=False, token=None):
if not proxy:
self._client = WavefrontDirectClient(server, token)
else:
self._client = WavefrontProxyClient(
host=server, metrics_port=2878,
distribution_port=2878, tracing_port=30000)
def create_record_count(self, proto_record_dict, created):
record_count = RecordCount(self._client, proto_record_dict, created)
record_count.save()
def create_traffic_record(self, traffic_record):
record = TrafficRecord(self._client, traffic_record)
record.save()
def create_resource_record(self, record):
prefix = 'axon.resources.'
tags = {"datacenter": conf.TESTBED_NAME,
"test_id": conf.TEST_ID}
for key, val in record.as_dict().items():
if key in ['_id', '_timestamp']:
continue
metric = prefix + key
self._client.send_metric(
name=metric, value=val,
timestamp=record.timestamp,
source=conf.WAVEFRONT_SOURCE_TAG, tags=tags)
def create_latency_stats(self, latency_sum, samples, created):
latency_stats = LatencyStats(
self._client, latency_sum, samples, created)
latency_stats.save()
def client(self):
if not self._client:
self._client = WavefrontProxyClient(host=self.host,
metrics_port=self.port,
distribution_port=None,
tracing_port=None)
return self._client
'--service',
dest='service',
action='store_true',
help='proccess "service-perfdata" (default: "host-perfdata")')
parser.add_argument('--test', dest='test', action='store_true')
parser.add_argument('--wf_server', dest="server")
parser.add_argument('--wf_token', dest="token")
parser.add_argument('--wf_proxy_addr', dest="addr")
parser.add_argument('--wf_proxy_port', dest="port")
args = parser.parse_args()
logging.info(args)
if args.addr is not None and args.port is not None:
client = WavefrontProxyClient(host=args.addr,
metrics_port=args.port,
distribution_port=40000,
tracing_port=30000)
elif args.server is not None and args.token is not None:
client = WavefrontDirectClient(server=args.server,
token=args.token,
max_queue_size=50000,
batch_size=10000,
flush_interval_seconds=15)
else:
parser.print_help()
exit(-1)
try:
main()
finally:
client.close()
################################################################################
### Copyright (C) 2020 VMware, Inc. All rights reserved.
### SPDX-License-Identifier: BSD-2-Clause
################################################################################
import serial, time
from time import gmtime, strftime
from datetime import datetime
ser = serial.Serial('/dev/ttyUSB0')
from wavefront_sdk import WavefrontProxyClient
wavefront_sender = WavefrontProxyClient(
host="ec2-A-B-C-D.eu-west-2.compute.amazonaws.com",
metrics_port=2878,
distribution_port=2878,
tracing_port=30000,
)
while True:
now = datetime.now()
timestamp_nico = datetime.timestamp(now)
print("timestamp =", timestamp_nico)
data = []
for index in range(0, 10):
datum = ser.read()
data.append(datum)
pmtwofive = int.from_bytes(b''.join(data[2:4]), byteorder='little') / 10
print(pmtwofive)
wavefront_sender.send_metric(name="nvibert.pm2.5",
"&enforcement_point_path=/infra/sites/default/enforcement-points/vmc-enforcementpoint"
)
response = requests.get(myURL, headers=myHeader)
json_response = response.json()
json_response_status_code = response.status_code
if json_response_status_code == 200:
total_bytes = json_response['per_node_statistics'][0]['tx'][
'total_bytes']
return total_bytes
else:
print("fail")
wavefront_sender = WavefrontProxyClient(
host="ec2-A-B-C-D.eu-west-2.compute.amazonaws.com",
metrics_port=2878,
distribution_port=2878,
tracing_port=30000,
)
# --------------------------------------------
# ---------------- Main ----------------------
# --------------------------------------------
session_token = getAccessToken(Refresh_Token)
proxy = getNSXTproxy(ORG_ID, SDDC_ID, session_token)
edge_cluster_id = getSDDCEdgeCluster(proxy, session_token)
edge_path_0 = getSDDCEdgeNodes(proxy, session_token, edge_cluster_id, 0)
edge_path_1 = getSDDCEdgeNodes(proxy, session_token, edge_cluster_id, 1)
while True:
session_token = getAccessToken(Refresh_Token)
proxy = getNSXTproxy(ORG_ID, SDDC_ID, session_token)
'--service',
dest='service',
action='store_true',
help='proccess "service-perfdata" (default: "host-perfdata")')
parser.add_argument('--test', dest='test', action='store_true')
parser.add_argument('--wf_server', dest="server")
parser.add_argument('--wf_token', dest="token")
parser.add_argument('--wf_proxy_addr', dest="addr")
parser.add_argument('--wf_proxy_port', dest="port")
args = parser.parse_args()
logging.info(args)
if args.addr is not None and args.port is not None:
client = WavefrontProxyClient(host=args.addr,
metrics_port=args.port,
distribution_port=40000,
tracing_port=30000)
elif args.server is not None and args.token is not None:
client = WavefrontDirectClient(server=args.server,
token=args.token,
max_queue_size=50000,
batch_size=10000,
flush_interval_seconds=15)
print(client)
else:
parser.print_help()
exit(-1)
try:
startTime = time.time()
main()
WavefrontSpanReporter, ConsoleReporter
# pylint: disable=invalid-name
if __name__ == "__main__":
# Create Wavefront Span Reporter using Wavefront Direct Client.
direct_client = WavefrontDirectClient(
server="http://localhost:8080",
token="9ea0d7c3-311a-419b-86b1-7a515f4aff76",
max_queue_size=50000,
batch_size=10000,
flush_interval_seconds=5)
direct_reporter = WavefrontSpanReporter(direct_client)
# Create Wavefront Span Reporter using Wavefront Proxy Client.
proxy_client = WavefrontProxyClient(host="localhost",
tracing_port=30000,
distribution_port=40000,
metrics_port=2878)
proxy_reporter = WavefrontSpanReporter(proxy_client)
# Create Composite reporter.
# Use ConsoleReporter to output span data to console.
composite_reporter = CompositeReporter(proxy_reporter, direct_reporter,
ConsoleReporter())
# Create Tracer with Composite Reporter.
tracer = WavefrontTracer(reporter=composite_reporter)
global_tags = [("global_key", "global_val")]
# Create span1, return a newly started and activated Scope.
scope = tracer.start_active_span(operation_name="span1",