def send_metrics(currency_metrics):
sender = graphyte.Sender(cfg.graphite_host, prefix='currencies')
for metric in currency_metrics:
sender.send(metric["from_currency"] + ':' + metric["to_currency"],
metric["price"],
timestamp=parser.parse(metric["time"] + ' ' +
metric["timezone"]).timestamp())
def send_to_graf(self, dictionary, myport=2013, myprotocol='udp'):
for key in self.prepare_grafana(dictionary):
if (key[0], key[1]) is not None:
#print(key[0].lower(),key[1])
graphyte.Sender('graphite01.pic.es',
port=myport,
protocol=myprotocol,
prefix=self.gr_prefix +
socket.gethostname().replace(".", "_")).send(
key[0].lower(), key[1])
graphyte.Sender('graphite02.pic.es',
port=myport,
protocol=myprotocol,
prefix=self.gr_prefix +
socket.gethostname().replace(".", "_")).send(
key[0].lower(), key[1])
def __init__(self, user_id, id_pool, dd, templates, hyps, params):
self.name = "load"
self.sender = graphyte.Sender(GRAFANA['url'], prefix='isard-eval.{}'.format(self.name), port=GRAFANA['carbon_port'])
self.user_id = user_id
self.id_pool = id_pool
self.defined_domains = dd
self.templates = templates
self.hyps = hyps
self.params = params
self.running_grafana_stats = False
def __init__(
self,
graphyte_server: str,
logger: logging.Logger,
prefix: str = "machine_info",
update_interval_s: int = 10,
):
self._graphyte_server = graphyte_server
self._logger = logger
self._update_interval_s = update_interval_s
self._stop = False
self._sender = graphyte.Sender(self._graphyte_server, prefix=prefix)
def __init__(self, user_id, id_pool, dd, templates, hyps, params):
self.name = "ux"
self.code = "RR_stress_launch_apps"
self.sender = graphyte.Sender(GRAFANA['server'],
prefix='isard-eval.{}'.format(self.name),
port=GRAFANA['port'])
self.user_id = user_id
self.id_pool = id_pool
self.defined_domains = dd
self.templates = templates
self.hyps = hyps
self.params = params
self.steps = 3 # How many steps will start domains
self.initial_ux_iterations = 1
self.real_stop = True # Wait for auto stop domain
self.time_to_stop = 15 # Force to stop after X seconds
self.initial_ux = {} # one key for each template
self.names = [
"ram_hyp_usage", "cpu_hyp_usage", "cpu_hyp_iowait", "cpu_usage"
]
self.statistics = ["max", "min", "mean", "stdev"]
self.inc_statistics = ["mean", "stdev"]
self.calcule_ux = True
self.save_ux = True
self.data_ux_names = [
"execution_time", "inc_execution_time", "performance"
]
self._init_data_ux_names()
self.ux_scorers = {
"execution_time": {
"min": 0,
"max": 30,
"weight": 60,
"unit": "percent"
},
"cpu_hyp_iowait_stdev": {
"min": 0,
"max": 30,
"weight": 20,
"unit": "percent"
},
"cpu_usage_mean": {
"min": 0,
"max": 30,
"weight": 20,
"unit": "percent"
}
}
self.total_weights_ux_scorers = sum(v['weight']
for v in self.ux_scorers.values())
#GLOBALS
disthigh = 0
distlow = 1000
distavg = 0
count = 0
medianDistance = 0
CpuUtil = 0
GRAPHITE = "localhost"
HOT = "hot.pancamo.com"
myws = "KTXOLIVI"
mywslocation = "PancamoPointPier"
graphyte.init(GRAPHITE, prefix='wu.KTXOLIVI.PI2')
sender1 = graphyte.Sender(GRAPHITE, prefix='wu.KTXOLIVI.PI2')
#sender2 = graphyte.Sender(HOT, prefix='wu.KTXOLIVI.PI2')
SERIAL_PORT = "/dev/serial0" # or "COM4" or whatever
serialport = serial.Serial(SERIAL_PORT, 9600)
# This function measures a distance
def read_me007ys(ser, timeout=1.0):
ts = time.time()
buf = bytearray(3)
idx = 0
while True:
# Option 1, we time out while waiting to get valid data
""" pull local stats and post them to carbon-relay """
from datetime import datetime
import logging
import json
from os import environ
import sys
import codalib
import graphyte
if __name__ == "__main__":
# Load sensitive config
try:
with open('/etc/testnet_config.json') as config_file:
config = json.load(config_file)
testnet = config['testnet']
except IOError as error:
print('Error opening secrets config:', error)
sys.exit(1)
# get stats
stats = codalib.coda_status()
gmetrics = graphyte.Sender('localhost',
prefix='testnet.%s.stats' % testnet,
log_sends=True)
gmetrics.send('block_count', stats['blockchain_length'])
gmetrics.send('peer_count', len(stats['peers']))
gmetrics.send('account_count', stats['num_accounts'])
gmetrics.send('user_commands', stats['user_commands_sent'])
def __init__(self, server, port, prefix):
self.sender = graphyte.Sender(server, port=port, prefix=prefix)
def send_real_weather(weather):
sender = graphyte.Sender("graphite", prefix="weather")
sender.send("real.temperature", get_temperature(weather))
sender.send("real.wind_speed", get_wind_speed(weather))
sender.send("real.humidity", get_humidity(weather))
def send_current_metric(current_temp):
sender = graphyte.Sender(GRAPHITE_HOST, prefix='yandex_weather')
sender.send('current.temp', current_temp)
def send_metrics(covid_data):
sender = graphyte.Sender(GRAPHITE_HOST, prefix='covid')
for covid in covid_data:
sender.send(covid[0], covid[1])
def send_metrics(values):
sender = graphyte.Sender(GRAPHITE_HOST, prefix='weather')
for value in values:
sender.send(value[0], value[1])
def send_metrics(games):
sender = graphyte.Sender(GRAPHITE_HOST, prefix='games')
for game in games:
sender.send(game[0], game[1])
'nonce': nonce})
# Load sensitive config
try:
with open('/etc/testnet_config.json') as config_file:
config = json.load(config_file)
elastic_url = config['elastic_url']
testnet = config['testnet']
except IOError as error:
print('Error opening secrets config:', error)
sys.exit(1)
dumped_ledger = cli('coda advanced dump-ledger -json')
for line in dumped_ledger.splitlines():
jline = json.loads(line)
nonce_sum = 0
balance_sum = 0
if 'public_key' in jline:
nonce_metrics = graphyte.Sender('localhost', prefix='testnet.%s.stats.nonce_bykey.%s' % (testnet, jline['public_key'][:12]))
nonce_metrics.send('nonce_count',int(jline['nonce']))
nonce_sum += int(jline['nonce'])
balance_metrics = graphyte.Sender('localhost', prefix='testnet.%s.stats.balance_bykey.%s' % (testnet, jline['public_key'][:12]))
balance_metrics.send('balance', int(jline['balance']))
balance_sum += int(jline['balance'])
sum = graphyte.Sender('localhost', prefix='testnet.%s.stats' % (testnet), log_sends=True)
sum.send('nonce_sum', nonce_sum)
#!/usr/bin/python3
# simple status counters in graphite
import json
import socket
import graphyte
import subprocess
def cli(cmd='uname'):
result = subprocess.run(cmd.split(), stdout=subprocess.PIPE)
return(result.stdout.decode('utf-8').strip())
# Load sensitive config
try:
with open('/etc/testnet_config.json') as config_file:
config = json.load(config_file)
testnet = config['testnet']
except IOError as error:
print('Error opening secrets config:', error)
sys.exit(1)
hostname = socket.gethostname().replace('.','_')
status_metrics = graphyte.Sender('localhost', prefix='testnet.%s.status.byhost.%s' % (testnet, hostname))
status = json.loads(cli('coda client status -json'))
for stat in ['uptime_secs', 'blockchain_length']:
status_metrics.send(stat,int(status[stat]))
status_metrics.send('peer_count',int(len(status['peers'])))
#app.debug = True
app.use_reloader = False
app.debug = False
CURPROBES = ""
if not os.path.isfile(probe_file):
print("Probe file: %s not found - exiting" % probe_file)
sys.exit(1)
f = open(probe_file, "rb")
raw_probe = f.read().decode('utf-8')
f.close()
PROBES = json.loads(raw_probe)
if log_graphite:
gSend = graphyte.Sender('graphite')
FLOG = None
def main():
global CURPROBES
global GASVAL
global CHAMBER_AVG
global CHAMBER_TARGET
global FLOG
print("Init of probe data")
getSH(0)
getSH(1)
getSH(2)
debug = False
# sensitive config
try:
with open('/etc/testnet_config.json') as config_file:
config = json.load(config_file)
elastic_url = config['elastic_url']
testnet = config['testnet']
except IOError as error:
testnet = 'UNKNOWN'
myHostName = socket.gethostname().replace('.', '_')
count = 0
for entry in get_trust():
if 'ip' in entry:
friendly_ip = entry['ip'].replace('.', '_')
# skip small values
if abs(entry['status']['trust']) < 0.001:
continue
if debug:
print(json.dumps(entry, indent=2))
metrics = graphyte.Sender('localhost', prefix='trust.%s.by_peer.%s.%s' % (
testnet, myHostName, friendly_ip))
metrics.send('trust', entry['status']['trust'])
count += 1
print ('Sent %s trust metrics.' % count)
def send_metrics(metrics):
sender = graphyte.Sender(GRAPHITE_HOST, prefix='weather')
for metric in metrics:
sender.send(metric[0], metric[1])
def __init__(self, host=None, port=None, prefix=None):
self.sender = graphyte.Sender(host or os.environ["GRAPHITE_HOST"], port=port or int(os.environ["GRAPHITE_PORT"]), prefix=prefix or "nandy")
def send_metrics(value):
sender = graphyte.Sender(GRAPHITE_HOST, prefix='stocks')
sender.send("YNDX", value)
def send_metrics(weather):
sender = graphyte.Sender(GRAPHITE_HOST, prefix='weather')
print(weather, file=sys.stderr)
for weather_param in weather:
sender.send(weather_param[0], float(weather_param[1]))
mydata = json.loads(r.text)['data']['blocks']['nodes']
for key in mydata:
if 'creator' in key:
pubkey = key['creator']
if pubkey in key_to_user:
# print(key_to_user[pubkey])
myresults[key_to_user[pubkey]] += 1
return (myresults)
if __name__ == "__main__":
# Load sensitive config
try:
with open('/etc/testnet_config.json') as config_file:
config = json.load(config_file)
testnet = config['testnet']
except IOError as error:
print('Error opening secrets config:', error)
sys.exit(1)
results = get_blocks()
metrics = graphyte.Sender('localhost',
prefix='testnet.%s.stats.blocks_byuser' %
(testnet))
for user in results:
print('data', user, results[user])
metrics.send(user, int(results[user]))
import json
import urllib.request
import graphyte
import logging
import time
logging.getLogger().setLevel(logging.INFO)
GRAPHITE_HOST = 'graphite'
CURRENCIES = ['CAD', 'CHF', 'USD']
BASE_URL = 'https://api.exchangeratesapi.io/latest'
SENDER = graphyte.Sender(GRAPHITE_HOST, prefix='currencies')
def main():
logging.info("Request: %s", BASE_URL)
response = json.loads(
urllib.request.urlopen(BASE_URL).read().decode('utf-8'))
logging.info('Response: %s', response)
for currency in CURRENCIES:
SENDER.send(currency, response['rates'][currency])
if __name__ == '__main__':
while True:
try:
main()
except:
logging.exception("Unhandled exception")
time.sleep(5)
def send_metrics(predictions):
sender = graphyte.Sender(GRAPHITE_HOST, prefix='currencies_predictions')
for prediction in predictions:
sender.send(prediction[0], prediction[1], timestamp=time.time() + day_duration)
def send_metrics(gold_prices_series, data_type):
sender = graphyte.Sender(GRAPHITE_HOST, prefix='gold_prices')
for gold_price in gold_prices_series:
sender.send(data_type, gold_price[1])
def send_metrics(radiation, info_type):
sender = graphyte.Sender(GRAPHITE_HOST, prefix='radiation')
for i, r in enumerate(radiation):
sender.send(info_type, r[0], timestamp=r[1])
def send_metrics(currencies):
sender = graphyte.Sender(GRAPHITE_HOST, prefix='currencies')
for currency in currencies:
sender.send(currency[0], currency[1])
def send_forecast_metric(weather, timestamp):
sender = graphyte.Sender(GRAPHITE_HOST, prefix='yandex_weather')
sender.send('forecast.temp', weather, time.time() + 30)
