def collect(self): metrics = self._get_metrics() if metrics: for k, v in metrics.items(): metric = Metric(k, k, 'counter') labels = {} labels.update(self._labels) metric.add_sample(k, value=v, labels=labels) if metric.samples: yield metric else: pass
def collect(self): pewdiepie = 'pewdiepie' tseries = 'tseries' youtube_key = 'YOUR_API_KEY' endpoint = 'https://www.googleapis.com/youtube/v3/channels?part=statistics&forUsername='******'YOUTUBE_HOST', endpoint) status = 'running' url = youtube_host + pewdiepie + '&key=' + youtube_key r = requests.get(url, verify=False) try: #create pewdiepie metric metric = Metric('subscriber_count', 'Current number of subs', 'gauge') metric.add_sample( 'subscriber_count', value=(( r.json()["items"][0]["statistics"]["subscriberCount"])), labels={'Channel': 'PewDiePie'}) # yield metric except: pass url = youtube_host + tseries + '&key=' + youtube_key r = requests.get(url, verify=False) try: #create tseries metric # metric = Metric('tseries_subs', 'Current number of non-bros', 'gauge') metric.add_sample( 'subscriber_count', value=(( r.json()["items"][0]["statistics"]["subscriberCount"])), labels={'Channel': 'Tseries'}) yield metric except: pass
def collect(self): r = requests.get('%s/system/health/v1/units' % self._url, headers={'Authorization': 'token=' + self._token}, verify=False) # if failed, refresh token if r.status_code == 401: logging.info("Failed auth, getting new auth token") self.get_token() self.collect() else: healthmetrics = r.json() for hm in healthmetrics['units']: logging.info(hm) hm_removed_periods = hm[u'id'].replace(".", "_") hm_removed_dashes = hm_removed_periods.replace("-", "_") metric = Metric(hm_removed_dashes, '', 'gauge') metric.add_sample(hm_removed_dashes, value=hm[u'health'], labels={ 'name': hm[u'name'], 'desc': hm[u'description'] }) yield metric logging.info("%s:%d" % (hm[u'id'], hm[u'health']))
def collect(self): jsondata = collect(self.jsondata) metric = Metric(self.metric_name, "{}_{}".format(self.metric_name, self.hostname), 'gauge') metric.add_sample(self.metric_name, value=jsondata['data']['data']['value'], labels={ 'host': self.hostname, '{}_subvalue'.format(self.metric_name): 'None', }) yield metric
def collect(self): # get metric about control nodes url = self._endpoint # Fetch the JSON response = json.loads(requests.get(url).content.decode('UTF-8')) metric = Metric('control_node_metrics', 'metrics for control nodes', 'summary') for entry in response['value']: name = entry['name'] if ('NodeStatus' in entry['value']): tmp = entry['value']['NodeStatus'] system_mem_usage = tmp['system_mem_usage'] system_cpu_info = tmp['system_cpu_info'] for k in system_mem_usage: if (k == 'node_type'): print ('not') continue print(k,type(k)) metric.add_sample('system_mem_usage_'+k, value=system_mem_usage[k], labels={"host_name": name}) for k in system_cpu_info: metric.add_sample('system_cpu_info_'+k, value=system_cpu_info[k], labels={"host_name": name}) # Export metric yield metric
def collect(self): # get metric about control nodes url = self._endpoint # Fetch the JSON response = json.loads(requests.get(url).content.decode('UTF-8')) json_all_cfdbnode = response['value'] number_cfdbnode = len(json_all_cfdbnode) # Add metric system_mem_usage_used metric = Metric('contrail_status', '', 'gauge') for i in range(number_cfdbnode): current_json_cfdbnode = json_all_cfdbnode[i]['value'] current_metric = current_json_cfdbnode['NodeStatus']['process_info'] for k in range(len(current_metric)): metric.add_sample('contrail_status', value = 1, labels = { 'process_name': current_metric[k]['process_name'], 'process_state': current_metric[k]['process_state'], 'last_start_time': current_metric[k]['last_start_time'], 'config_node': json_all_cfdbnode[i]['name'] }) yield metric metric = Metric('config_node_avl', 'List of config databases node available', 'gauge') for i in range(number_cfdbnode): metric.add_sample('config_node_avl', value = 1, labels = { 'config_host': json_all_cfdbnode[i]['name'] }) yield metric
def parse(self, t: tuple, metrics: list, endpoint, label={}) -> list: NoneType = type(None) if isinstance(t[1], (int, float, bool, str, NoneType)): mtr_d = {} if self._show_type: k = self.correct_metric_name(t[0] + '_value') else: k = self.correct_metric_name(t[0]) v = t[1] mtr_d = self.parse_base_turple((k, v), endpoint, label=label) metric = Metric(mtr_d['name'], '', 'gauge') metric.add_sample(self._prefix + mtr_d['name'], value=mtr_d['value'], labels=mtr_d['labels']) metrics.append(metric) if isinstance(t[1], list): cnt = 0 for i in t[1]: l = {"index": str(t[1].index(i))} name = f'{t[0]}_{cnt}' if self._show_type: name += '_list' self.parse((name, i), metrics, endpoint, label=l) cnt += 1 if isinstance(t[1], dict): for i in t[1].items(): name = t[0] if self._show_type: name += '_dict_' else: name += '_' self.parse((name + i[0], i[1]), metrics, endpoint)
def collect(self): with lock: log.info('collecting...') response = self.client.tickers() metric = Metric('market', 'crypto currency market metric values', 'gauge') print(response) # tick = response["tick"] # # best_buy_price = tick["bids"][0][0] # best_sell_price = tick["asks"][0][0] # for k, v in response.items(): metric.add_sample(k, value=v, labels={ "currency": "bitcoin", }) # metric.add_sample( # "bitcoin_market", # value=sum([best_buy_price, best_sell_price]) / 2.0, # labels={ # "currency": "bitcoin", # "type": "spot", # "id": "bitcoin", # }) yield metric
async def get_wallet_balance(self): name = "get_wallet_balance" start = time.time() print(name + ": Starting") client = await WalletRpcClient.create("host.docker.internal", 9256, Path("/root/.chia/mainnet"), self.config) wallets = await client.get_wallets() height_info = await client.get_height_info() metric1 = Metric('chia_wallet_balance', "Wallet balance", "summary") for wallet in wallets: results = await client.get_wallet_balance(wallet["id"]) metric1.add_sample('chia_wallet_balance', value=results["confirmed_wallet_balance"], labels={"wallet_id": str(wallet["id"])}) metric2 = Metric('chia_wallet_height', 'Block Height of Chia Wallet', 'summary') metric2.add_sample('chia_wallet_height', value=height_info, labels={}) client.close() print(name + ": Done in " + str(time.time() - start) + " seconds") return [metric1, metric2]
def collect(self): url = self._endpoint response = json.loads(requests.get(url).content.decode('UTF-8')) json_all_bgp = response['value'] metric = Metric('bgp_state_info', '', 'gauge') for i in range(len(json_all_bgp)): cbgp = json_all_bgp[i]['value'] conn = json_all_bgp[i]['name'].split(':') snode = conn[4] dnode = conn[9] if ('BgpPeerInfoData' in cbgp and 'state_info' in cbgp['BgpPeerInfoData']): metric.add_sample( 'bgp_state_info', value=1, labels={ 'bgp_last_state': cbgp['BgpPeerInfoData']['state_info']['last_state'], 'bgp_state': cbgp['BgpPeerInfoData']['state_info']['state'], 'control_node': snode, 'peer': dnode }) yield metric
def collect(self): # Fetch the JSON #response = json.loads(requests.get(self._endpoint).content.decode('UTF-8')) # fetch json from file json_data = open("./indices").read() #This function will summarize each index pattern. The return would be a list with each indice group #For example, for a group of indice called customer-metrics-*, a regex like '(.*-metrics).*' will return 'customer-metrics' indicesGroups = summarizeIndices(json_data, indicesPattern) #Call the function sum the total size in bytes of each indiceGroup. The return will be a dict with 1st group of match and they values indicesGroupSizes = collectIndicesGroupSizes(indicesGroups, json_data, indicesPattern) #Metric es_group_indices_size metric = Metric('es_group_indices_size', 'Size of a group of indices', 'gauge') #Run the indicesGroupSizes dict and add those infos at metric for labelValue, sizeValue in indicesGroupSizes.items(): metric.add_sample('es_group_indices_size', value=sizeValue, labels={'group': labelValue}) #Exporse the metric yield metric
def collect(self): cache_keys = { 'total_csize': 'Compressed size', 'total_size': 'Original size', 'unique_csize': 'Deduplicated size' } repo_keys = {'last_modified': 'Last backup date'} for d in self.dirs: host = basename(d) data = json.loads( subprocess.check_output(['/usr/bin/borg', 'info', d, '--json'])) stats = data['cache']['stats'] for key, desc in cache_keys.items(): mkey = f'borg_{key}' metric = Metric(mkey, desc, 'gauge') metric.add_sample(mkey, value=stats[key], labels={'host': host}) yield metric repo = data['repository'] for key, desc in repo_keys.items(): mkey = f'borg_{key}' metric = Metric(mkey, desc, 'gauge') diff = datetime.now() - datetime.fromisoformat(repo[key]) value = 0 if diff.days < 0 else diff.days metric.add_sample(mkey, value=value, labels={'host': host}) yield metric
def collect(self): response = self._get_metrics() if self._exclude: self.filter_exclude() for i in self._metric_collect: metric = Metric(i['name'], i['name'], i['metric_type']) for m in i['collect']: labels = {} labels.update(self._labels) labels.update({'original_metric': m['metric_name']}) if m.get('label'): labels.update(m['label']) try: metric.add_sample(i['name'], value=response[m['metric_name']], labels=labels) except KeyError: pass if metric.samples: yield metric else: pass
def collect(self): # query the api r = requests.get(self.endpoint) request_time = r.elapsed.total_seconds() log.info('elapsed time -' + str(request_time)) response = json.loads(r.text[r.text.index("(") + 1:r.text.rindex(")")]) metric = Metric( 'spotinstance_api_response_time', 'Total time for the AWS Spot Instance API to respond.', 'summary') # add the response time as a metric metric.add_sample('spotinstance_api_response_time', value=float(request_time), labels={'name': 'AWS Spot Instance Pricing API'}) yield metric metric = Metric('spotinstance', 'spot instance pricing', 'gauge') # each['region'] = us-east for each in response['config']['regions']: # each['sizes'] = list of instance sizes for that in each['instanceTypes']: for it in that['sizes']: if it['valueColumns'][0]['prices']['USD'] != 'N/A*': metric.add_sample( 'spotinstance', value=float( it['valueColumns'][0]['prices']['USD']), labels={ 'region': each['region'], 'size': it['size'].replace('.', '_') }) yield metric
def collect(self): # query the api r = requests.get(self.endpoint) request_time = r.elapsed.total_seconds() log.info('elapsed time -' + str(request_time)) response = json.loads(r.content.decode('UTF-8')) # setup the metric metric = Metric('coinmarketcap_response_time', 'Total time for the coinmarketcap API to respond.', 'summary') # add the response time as a metric metric.add_sample('coinmarketcap_response_time', value=float(request_time), labels={'name': 'coinmarketcap.com'}) yield metric metric = Metric('coin_market', 'coinmarketcap metric values', 'gauge') for each in response: for that in [ 'rank', 'price_usd', 'price_btc', '24h_volume_usd', 'market_cap_usd', 'available_supply', 'total_supply', 'percent_change_1h', 'percent_change_24h', 'percent_change_7d' ]: coinmarketmetric = '_'.join(['coin_market', that]) if each[that] is not None: metric.add_sample(coinmarketmetric, value=float(each[that]), labels={ 'id': each['id'], 'name': each['name'], 'symbol': each['symbol'] }) yield metric
def collect(self): # Fetch the JSON peer_info = merged_peer_info(self.wg) peer_metadata = get_peer_metadata() for iface in peer_info: metric = Metric(f"interface_info_{iface['iface']}", 'interface_information', 'summary') for peer in iface['peers']: peer.update(peer_metadata.get(peer['public_key'], {})) for k, v in peer.items(): if k not in [ 'latency_ms', 'packet_loss', 'rx_bytes', 'tx_bytes' ]: continue metric.add_sample(f"iface_information_{k}", value=str(v), labels={ 'hostname': os.environ.get( 'SYNTROPY_AGENT_NAME', socket.gethostname()), 'ifname': iface['iface'], 'peer': peer['public_key'], 'internal_ip': peer['internal_ip'], "device_id": peer.get('device_id'), "device_name": peer.get('device_name'), "device_public_ipv4": peer.get('device_public_ipv4') }) yield metric
def collect(self): cache_keys = { "total_csize": "Compressed size", "total_size": "Original size", "unique_csize": "Deduplicated size", } repo_keys = {"last_modified": "Last backup date"} for d in self.dirs: host = basename(d) data = json.loads( subprocess.check_output(["/usr/bin/borg", "info", d, "--json"], input=b"y")) stats = data["cache"]["stats"] for key, desc in cache_keys.items(): mkey = f"borg_{key}" metric = Metric(mkey, desc, "gauge") metric.add_sample(mkey, value=stats[key], labels={"host": host}) yield metric repo = data["repository"] for key, desc in repo_keys.items(): mkey = f"borg_{key}" metric = Metric(mkey, desc, "gauge") diff = datetime.now() - datetime.strptime( repo[key], "%Y-%m-%dT%H:%M:%S.%f") value = 0 if diff.seconds < 0 else diff.seconds metric.add_sample(mkey, value=value, labels={"host": host}) yield metric
async def get_pricing(self): name = "get_pricing" start = time.time() print(name + ": Starting") try: resp = requests.get( "https://coinmarketcap.com/currencies/chia-network/") soup = BeautifulSoup(resp.content, features="lxml") usd_price = float( soup.find_all("div", class_="priceValue___11gHJ")[0].text[1:].replace( ",", "")) vol_24hr = float( soup.find_all("div", class_="statsValue___2iaoZ")[2].text[1:].replace( ",", "")) metric1 = Metric('chia_usd_price', 'Chia USD Price', "summary") metric1.add_sample('chia_usd_price', value=usd_price, labels={}) metric2 = Metric('chia_24hr_volume_usd', 'Chia 24 Hour Volume Traded', "summary") metric2.add_sample('chia_24hr_volume_usd', value=vol_24hr, labels={}) except Exception as e: print(name + ": Failed to run. Error follows") print(e) return [] print(name + ": Done in " + str(time.time() - start) + " seconds") return [metric1, metric2]
def collect(self): # Fetch the JSON response = json.loads( requests.get(self._endpoint).content.decode('UTF-8')) # Metrics with labels for the documents loaded metric = Metric('svc_fps', 'Requests failed', 'gauge') metric.add_sample('svc_fps', value=response, labels={}) yield metric
def collect(self): metric = Metric("hh", "help", 'histogram') # This is not sane, but it covers all the cases. metric.add_sample("hh_bucket", {"le": "1"}, 0, None, Exemplar({'a': 'b'}, 0.5)) metric.add_sample("hh_bucket", {"le": "2"}, 0, None, Exemplar({'le': '7'}, 0.5, 12)) metric.add_sample("hh_bucket", {"le": "3"}, 0, 123, Exemplar({'a': 'b'}, 2.5, 12)) metric.add_sample("hh_bucket", {"le": "4"}, 0, None, Exemplar({'a': '\n"\\'}, 3.5)) metric.add_sample("hh_bucket", {"le": "+Inf"}, 0, None, None) yield metric
def collect(self): # get metric about control nodes urls = self._endpoint metric = Metric('contrail_status', '', 'gauge') # Fetch the JSON for j in range(len(urls)): response = json.loads( requests.get(urls[j]).content.decode('UTF-8')) json_all_node = response['value'] number_node = len(json_all_node) # Add metric system_mem_usage_used # metric = Metric('contrail_status', '', 'gauge') for i in range(number_node): current_json_node = json_all_node[i]['value'] if ('NodeStatus' in current_json_node and 'process_info' in current_json_node['NodeStatus']): current_metric = current_json_node['NodeStatus'][ 'process_info'] for k in range(len(current_metric)): metric.add_sample( 'contrail_status', value=1 if current_metric[k]['process_state'] == 'PROCESS_STATE_RUNNING' else 0, labels={ 'process_name': current_metric[k]['process_name'], 'process_state': current_metric[k]['process_state'], 'last_start_time': current_metric[k]['last_start_time'], 'node': re.sub('.local', '', json_all_node[i]['name']), 'node_type': re.sub(r'[:-]', '_', self._node[j]) }) yield metric # Metric for j in range(len(urls)): response = json.loads( requests.get(urls[j]).content.decode('UTF-8')) json_all_node = response['value'] number_node = len(json_all_node) metric = Metric(re.sub(r'[:-]', '_', self._node[j]), 'List of node available', 'gauge') for k in range(number_node): metric.add_sample( re.sub(r'[:-]', '_', self._node[j]), value=1, labels={'config_host': json_all_node[k]['name']}) yield metric
def collect(self): with lock: # query the api response = self.client.quote() metric = Metric('coin_market_quote', 'coinmarketcap quote', 'gauge') coinmarketmetric = f'coin_market_quote_{currency}' quote = response['data'][self.symbol]['quote'][currency] metric.add_sample(coinmarketmetric, value=float(quote['price']), labels={'symbol': self.symbol}) yield metric
def _get_scrape_duration_metric(self, start_time): metric = Metric( 'trafficserver_scrape_duration_seconds', 'Time the Traffic Server scrape took, in seconds.', 'gauge') metric.add_sample( 'trafficserver_scrape_duration_seconds', value=time.time() - start_time, labels={}) return metric
def getMetrics(self,port): metrics=[] data={"fast": random.random(),"slow": random.random()} for index in range(100): metric = Metric("svcs_"+str(index)+"_"+ str(port)+"_documents_loaded", 'Help text', 'gauge') for k, v in data.items(): metric.add_sample("svcs_"+str(index)+"_"+ str(port)+"_documents_loaded",value=v, labels={'repository': k}) metrics.append(metric) #metrics.append(GaugeMetricFamily("svcs_"+str(index)+"_"+ str(port)+"_documents_loaded", 'Help text', value=random.random())) return metrics
def collect(self): packages = checkupdates() metric = Metric('arch_checkupdates', 'Arch Linux Packages out of date', 'gauge') metric.add_sample('arch_checkupdates', value=(packages), labels={}) yield metric security_issues = vulernablepackges() metric = Metric('arch_audit', 'Arch Audit Packages', 'gauge') metric.add_sample('arch_audit', value=(security_issues), labels={}) yield metric
def collect(self): bmp = BMP085(0x77) temp = bmp.readTemperature() pressure = bmp.readPressure() temp_metric = Metric('bmp180_temp', 'BMP180 temperature', 'gauge') temp_metric.add_sample('bmp180_temp', value=temp, labels={}) yield temp_metric pressure_metric = Metric('bmp180_pressure', 'BMP180 pressure', 'gauge') pressure_metric.add_sample('bmp180_pressure', value=pressure, labels={}) yield pressure_metric
def collect(self): start_time = datetime.datetime.now() ret = self.kube_metrics() end_time = datetime.datetime.now() total_time = (end_time - start_time).total_seconds() nodes = ret['nodes'] pods = ret['pods'] metrics_nodes_mem = Metric('kube_metrics_server_nodes_mem', 'Metrics Server Nodes Memory', 'gauge') metrics_nodes_cpu = Metric('kube_metrics_server_nodes_cpu', 'Metrics Server Nodes CPU', 'gauge') metrics_response_time = Metric('kube_metrics_server_response_time', 'Metrics Server API Response Time', 'gauge') metrics_response_time.add_sample('kube_metrics_server_response_time', value=total_time, labels={ 'api_url': '{}/metrics.k8s.io'.format(self.api_url) }) yield metrics_response_time for node in nodes.get('items', []): node_instance = node['metadata']['name'] node_cpu = node['usage']['cpu'] node_cpu = node_cpu.translate(str.maketrans('', '', string.ascii_letters)) node_mem = node['usage']['memory'] node_mem = node_mem.translate(str.maketrans('', '', string.ascii_letters)) metrics_nodes_mem.add_sample('kube_metrics_server_nodes_mem', value=int(node_mem), labels={ 'instance': node_instance }) metrics_nodes_cpu.add_sample('kube_metrics_server_nodes_cpu', value=int(node_cpu), labels={ 'instance': node_instance }) yield metrics_nodes_mem yield metrics_nodes_cpu metrics_pods_mem = Metric('kube_metrics_server_pods_mem', 'Metrics Server Pods Memory', 'gauge') metrics_pods_cpu = Metric('kube_metrics_server_pods_cpu', 'Metrics Server Pods CPU', 'gauge') for pod in pods.get('items', []): pod_name = pod['metadata']['name'] pod_namespace = pod['metadata']['namespace'] pod_container_mem = 0 pod_container_cpu = 0 pod_container_name = "" for container in pod['containers']: pod_container_name = container['name'] pod_container_cpu = container['usage']['cpu'] pod_container_cpu = pod_container_cpu.translate(str.maketrans('', '', string.ascii_letters)) pod_container_mem = container['usage']['memory'] pod_container_mem = pod_container_mem.translate(str.maketrans('', '', string.ascii_letters)) if not any(blacklisted in self.names_blacklist for blacklisted in [pod_container_name, pod_name, pod_namespace]): metrics_pods_mem.add_sample('kube_metrics_server_pods_mem', value=int(pod_container_mem), labels={ 'pod_name': pod_name, 'pod_namespace': pod_namespace, 'pod_container_name': pod_container_name }) metrics_pods_cpu.add_sample('kube_metrics_server_pods_cpu', value=int(pod_container_cpu), labels={ 'pod_name': pod_name, 'pod_namespace': pod_namespace, 'pod_container_name': pod_container_name }) yield metrics_pods_mem yield metrics_pods_cpu
def _get_scrape_duration_metric(self, start_time): metric = Metric( "trafficserver_scrape_duration_seconds", "Time the Traffic Server scrape took, in seconds.", "gauge", ) metric.add_sample( "trafficserver_scrape_duration_seconds", value=time.time() - start_time, labels={}, ) return metric
def collect(self): # define environment variables zabbix_exp_url = os.environ.get('ZABBIX_EXP_URL', 'http://localhost/') zabbix_exp_username = os.environ.get('ZABBIX_EXP_USERNAME', 'Admin') zabbix_exp_password = os.environ.get('ZABBIX_EXP_PASSWORD', 'zabbix') zapi = ZabbixAPI(zabbix_exp_url) zapi.login(zabbix_exp_username, zabbix_exp_password) # create a prometheus metric metric = Metric('zabbix_warning', 'Current Zabbix Warning Count', 'gauge') # Get a list of all issues (AKA tripped triggers) triggers = zapi.trigger.get( only_true=1, skipDependent=1, monitored=1, active=1, output='extend', expandDescription=1, selectHosts=['host'], ) # Do another query to find out which issues are Unacknowledged unack_triggers = zapi.trigger.get( only_true=1, skipDependent=1, monitored=1, active=1, output='extend', expandDescription=1, selectHosts=['host'], withLastEventUnacknowledged=1, ) unack_trigger_ids = [t['triggerid'] for t in unack_triggers] for t in triggers: t['unacknowledged'] = True if t['triggerid'] in unack_trigger_ids \ else False # Print a list containing only "tripped" triggers # Sum triggers which value is 1 warn_cnt = 0 for t in triggers: if int(t['value']) == 1: warn_cnt += 1 # append data to the metric metric.add_sample('zabbix_warning', value=int(warn_cnt), labels={}) yield metric
def collect(self): print 'Go to localhost' user1 = os.popen( "mpstat -P ALL 1 1 | awk '/Average:/ && $2 ~ /[a-z]/ {print $3}'" ).readline().strip() nice1 = os.popen( "mpstat -P ALL 1 1 | awk '/Average:/ && $2 ~ /[a-z]/ {print $4}'" ).readline().strip() syst = os.popen( "mpstat -P ALL 1 1 | awk '/Average:/ && $2 ~ /[a-z]/ {print $5}'" ).readline().strip() iowait1 = os.popen( "mpstat -P ALL 1 1 | awk '/Average:/ && $2 ~ /[a-z]/ {print $6}'" ).readline().strip() idle1 = os.popen( "mpstat -P ALL 1 1 | awk '/Average:/ && $2 ~ /[a-z]/ {print $12}'" ).readline().strip() metric = Metric('Utilization_at_user_level', 'Percentage of utilization at user level', 'summary') metric.add_sample('Utilization_at_user_level', value=float(user1), labels={}) yield metric metric = Metric( 'Utilization_at_user_level_nicepriority', 'Percentage of utilization at user level with nice priority', 'summary') metric.add_sample('Utilization_at_user_level_nicepriority', value=float(nice1), labels={}) yield metric metric = Metric('Utilization_at_kernel_level', 'Percentage of utilization at kernel level', 'summary') metric.add_sample('Utilization_at_kernel_level', value=float(syst), labels={}) yield metric metric = Metric('IO_Wait', 'Time for which Cput is waiting for IO', 'summary') metric.add_sample('Utilization_at_kernel_level', value=float(iowait1), labels={}) yield metric metric = Metric('time_when_cpu_idle', 'Time for which Cpu was idle', 'summary') metric.add_sample('time_when_cpu_idle', value=float(idle1), labels={}) yield metric
def collect(self): self.metrics = self._get_metrics() if self.metrics: for k, v in self.metrics.items(): metric = Metric(k, k, 'gauge') labels = {} metric.add_sample(k, value=v, labels=labels) if metric.samples: yield metric else: pass
def collect(self): Symbols = [ 'GOOG', 'CSCO', 'BABA', 'APPL', 'IBM', 'GLOB' ] #Symbols = [ 'GOOG' ] strSymbols = cat_to_string(Symbols) JSp = GoogleFinanceAPI() if JSp.get(strSymbols): #JSp.Quotes2Stdout() # // Show a little data, just for testing JSp.JsonQot2Obj() metric = Metric('stock_quotes', 'stock quotes last price', 'gauge') for quote in JSp.QuotesList: # Convert quotes to metric metric.add_sample('stock_quotes', value=float(quote.Last), labels={'symbol': quote.Symbol}) yield metric
def _parse_volume_metrics(self, data, volume): metric = Metric( 'trafficserver_cache_avail_size_bytes_total', 'Total cache available.', 'gauge') metric.add_sample( 'trafficserver_cache_avail_size_bytes_total', value=data[('proxy.process.cache.volume_{0}.' 'bytes_used').format(volume)], labels={'volume': str(volume)}) yield metric metric = Metric( 'trafficserver_cache_used_bytes_total', 'Total cache used in bytes.', 'gauge') metric.add_sample( 'trafficserver_cache_used_bytes_total', value=data[('proxy.process.cache.volume_{0}.' 'bytes_total').format(volume)], labels={'volume': str(volume)}) yield metric metric = Metric( 'trafficserver_cache_operations_total', 'Cache operation count.', 'counter') for op in ('lookup', 'read', 'write', 'update', 'remove', 'evacuate', 'scan', 'read_busy'): for result in ('success', 'failure'): k = 'proxy.process.cache.volume_{volume}.{op}.{result}'.format( volume=volume, op=op, result=result) metric.add_sample( 'trafficserver_cache_operations_total', value=data[k], labels={'volume': str(volume), 'operation': op, 'result': result}) yield metric
def parse_metrics(self, data): """Generator for trafficserver metrics.""" # Counter for server restarts metric = Metric( 'trafficserver_restart_count', 'Count of traffic_server restarts.', 'counter') metric.add_sample( 'trafficserver_restart_count', value=data['proxy.node.restarts.proxy.restart_count'], labels={}) yield metric # # HTTP # # Connections metric = Metric( 'trafficserver_connections_total', 'Connection count.', 'counter') metric.add_sample( 'trafficserver_connections_total', value=data['proxy.process.http.total_client_connections'], labels={'source': 'client', 'protocol': 'http'}) metric.add_sample( 'trafficserver_connections_total', value=data['proxy.process.http.total_server_connections'], labels={'source': 'server', 'protocol': 'http'}) metric.add_sample( 'trafficserver_connections_total', value=data['proxy.process.http.total_parent_proxy_connections'], labels={'source': 'parent_proxy', 'protocol': 'http'}) yield metric # Incoming requests metric = Metric( 'trafficserver_requests_incoming', 'Incoming requests.', 'gauge') metric.add_sample( 'trafficserver_requests_incoming', value=data['proxy.process.http.incoming_requests'], labels={'protocol': 'http'}) yield metric # Client aborts metric = Metric( 'trafficserver_error_client_aborts_total', 'Client aborts.', 'counter') metric.add_sample( 'trafficserver_client_aborts_total', value=data['proxy.process.http.err_client_abort_count_stat'], labels={'protocol': 'http'}) yield metric # Connect fails metric = Metric( 'trafficserver_connect_failures_total', 'Connect failures.', 'counter') metric.add_sample( 'trafficserver_connect_failures_total', value=data['proxy.process.http.err_connect_fail_count_stat'], labels={'protocol': 'http'}) yield metric # Transaction count metric = Metric( 'trafficserver_transactions_total', 'Total transactions.', 'counter') metric.add_sample( 'trafficserver_transactions_total', value=data[('proxy.node.http.' 'user_agents_total_transactions_count')], labels={'source': 'user_agent', 'protocol': 'http'}) metric.add_sample( 'trafficserver_transactions_total', value=data[('proxy.node.http.' 'origin_server_total_transactions_count')], labels={'source': 'origin_server', 'protocol': 'http'}) yield metric # Transaction time spent, total metric = Metric( 'trafficserver_transactions_time_ms_total', 'Total transaction time (ms).', 'counter') metric.add_sample( 'trafficserver_transactions_time_total', value=data['proxy.process.http.total_transactions_time'], labels={}) yield metric # Transaction time spent, hits metric = Metric( 'trafficserver_hit_transaction_time_ms_total', 'Total cache hit transaction time (ms).', 'counter') metric.add_sample( 'trafficserver_hit_transaction_time_ms_total', value=data['proxy.process.http.transaction_totaltime.hit_fresh'], labels={'state': 'fresh', 'protocol': 'http'}) metric.add_sample( 'trafficserver_hit_transaction_time_ms_total', value=data[('proxy.process.http.transaction_totaltime.' 'hit_revalidated')], labels={'state': 'revalidated', 'protocol': 'http'}) yield metric # Transaction time spent, misses metric = Metric( 'trafficserver_miss_transaction_time_ms_total', 'Total cache miss transaction time (ms).', 'counter') metric.add_sample( 'trafficserver_miss_transaction_time_ms_total', value=data['proxy.process.http.transaction_totaltime.miss_cold'], labels={'state': 'cold', 'protocol': 'http'}) metric.add_sample( 'trafficserver_miss_transaction_time_ms_total', value=data[('proxy.process.http.transaction_totaltime.' 'miss_not_cacheable')], labels={'state': 'not_cacheable', 'protocol': 'http'}) metric.add_sample( 'trafficserver_miss_transaction_time_ms_total', value=data[('proxy.process.http.transaction_totaltime.' 'miss_changed')], labels={'state': 'changed', 'protocol': 'http'}) metric.add_sample( 'trafficserver_miss_transaction_time_ms_total', value=data[('proxy.process.http.transaction_totaltime.' 'miss_client_no_cache')], labels={'state': 'no_cache', 'protocol': 'http'}) yield metric # Transaction time spent, errors metric = Metric( 'trafficserver_error_transaction_time_ms_total', 'Total cache error transaction time (ms).', 'counter') metric.add_sample( 'trafficserver_error_transaction_time_ms_total', value=data[('proxy.process.http.transaction_totaltime.errors.' 'aborts')], labels={'state': 'abort', 'protocol': 'http'}) metric.add_sample( 'trafficserver_error_transaction_time_ms_total', value=data[('proxy.process.http.transaction_totaltime.errors.' 'possible_aborts')], labels={'state': 'possible_abort', 'protocol': 'http'}) metric.add_sample( 'trafficserver_error_transaction_time_ms_total', value=data[('proxy.process.http.transaction_totaltime.errors.' 'connect_failed')], labels={'state': 'connect_failed', 'protocol': 'http'}) metric.add_sample( 'trafficserver_error_transaction_time_ms_total', value=data[('proxy.process.http.transaction_totaltime.errors.' 'other')], labels={'state': 'other', 'protocol': 'http'}) yield metric # Transaction time spent, other metric = Metric( 'trafficserver_other_transaction_time_ms_total', 'Total other/unclassified transaction time (ms).', 'counter') metric.add_sample( 'trafficserver_other_transaction_time_ms_total', value=data[('proxy.process.http.transaction_totaltime.other.' 'unclassified')], labels={'state': 'unclassified', 'protocol': 'http'}) yield metric # Transaction count, hits metric = Metric( 'trafficserver_transaction_hits_total', 'Transaction hit counts.', 'counter') metric.add_sample( 'trafficserver_transaction_hits_total', value=data[('proxy.process.http.transaction_counts.' 'hit_fresh')], labels={'state': 'fresh', 'protocol': 'http'}) metric.add_sample( 'trafficserver_transaction_hits_total', value=data[('proxy.process.http.transaction_counts.' 'hit_revalidated')], labels={'state': 'revalidated', 'protocol': 'http'}) # Zero labels (misses) metric.add_sample( 'trafficserver_transaction_hits_total', value='0', labels={'state': 'cold', 'protocol': 'http'}) metric.add_sample( 'trafficserver_transaction_hits_total', value='0', labels={'state': 'not_cacheable', 'protocol': 'http'}) metric.add_sample( 'trafficserver_transaction_hits_total', value='0', labels={'state': 'changed', 'protocol': 'http'}) yield metric # Transaction count, misses metric = Metric( 'trafficserver_transaction_misses_total', 'Transaction miss counts.', 'counter') metric.add_sample( 'trafficserver_transaction_misses_total', value=data[('proxy.process.http.transaction_counts.' 'miss_cold')], labels={'state': 'cold', 'protocol': 'http'}) metric.add_sample( 'trafficserver_transaction_misses_total', value=data[('proxy.process.http.transaction_counts.' 'miss_not_cacheable')], labels={'state': 'not_cacheable', 'protocol': 'http'}) metric.add_sample( 'trafficserver_transaction_misses_total', value=data[('proxy.process.http.transaction_counts.' 'miss_changed')], labels={'state': 'changed', 'protocol': 'http'}) # Zero labels (hits) metric.add_sample( 'trafficserver_transaction_misses_total', value='0', labels={'state': 'fresh', 'protocol': 'http'}) metric.add_sample( 'trafficserver_transaction_misses_total', value='0', labels={'state': 'revalidated', 'protocol': 'http'}) yield metric # Transaction count, errors metric = Metric( 'trafficserver_transaction_errors_total', 'Transaction error counts.', 'counter') metric.add_sample( 'trafficserver_transaction_errors_total', value=data[('proxy.process.http.transaction_counts.errors.' 'aborts')], labels={'state': 'abort', 'protocol': 'http'}) metric.add_sample( 'trafficserver_transaction_errors_total', value=data[('proxy.process.http.transaction_counts.errors.' 'possible_aborts')], labels={'state': 'possible_abort', 'protocol': 'http'}) metric.add_sample( 'trafficserver_transaction_errors_total', value=data[('proxy.process.http.transaction_counts.errors.' 'connect_failed')], labels={'state': 'connect_failed', 'protocol': 'http'}) metric.add_sample( 'trafficserver_transaction_errors_total', value=data[('proxy.process.http.transaction_counts.errors.' 'other')], labels={'state': 'other', 'protocol': 'http'}) yield metric # Transaction count, others metric = Metric( 'trafficserver_transaction_others_total', 'Transaction other/unclassified counts.', 'counter') metric.add_sample( 'trafficserver_transaction_others_total', value=data[('proxy.process.http.transaction_counts.other.' 'unclassified')], labels={'state': 'unclassified', 'protocol': 'http'}) yield metric # HTTP Responses metric = Metric( 'trafficserver_responses_total', 'Response count.', 'counter') for code in TS_RESPONSE_CODES: key = 'proxy.process.http.{code}_responses'.format(code=code) metric.add_sample( 'trafficserver_responses_total', value=data[key], labels={'code': code, 'protocol': 'http'}) yield metric # HTTP Requests metric = Metric( 'trafficserver_requests_total', 'Request count.', 'counter') for method in HTTP_VERBS_LOWER: key = 'proxy.process.http.{method}_requests'.format(method=method) metric.add_sample( 'trafficserver_requests_total', value=data[key], labels={'method': method, 'protocol': 'http'}) yield metric # Invalid requests metric = Metric( 'trafficserver_client_requests_invalid_total', 'Invalid client requests.', 'counter') metric.add_sample( 'trafficserver_client_requests_invalid_total', value=data['proxy.process.http.invalid_client_requests'], labels={'protocol': 'http'}) yield metric # Requests without Host header metric = Metric( 'trafficserver_client_requests_missing_host_hdr_total', 'Client requests missing host header.', 'counter') metric.add_sample( 'trafficserver_client_requests_missing_host_hdr_total', value=data['proxy.process.http.missing_host_hdr'], labels={'protocol': 'http'}) yield metric # Request size metric = Metric( 'trafficserver_request_size_bytes_total', 'Request size in bytes.', 'counter') metric.add_sample( 'trafficserver_request_size_bytes_total', value=data['proxy.node.http.user_agent_total_request_bytes'], labels={'source': 'user_agent', 'protocol': 'http'}) metric.add_sample( 'trafficserver_request_size_bytes_total', value=data['proxy.node.http.origin_server_total_request_bytes'], labels={'source': 'origin_server', 'protocol': 'http'}) metric.add_sample( 'trafficserver_request_size_bytes_total', value=data['proxy.node.http.parent_proxy_total_request_bytes'], labels={'source': 'parent_proxy', 'protocol': 'http'}) yield metric # Response size metric = Metric( 'trafficserver_response_size_bytes_total', 'Response size in bytes.', 'counter') metric.add_sample( 'trafficserver_response_size_bytes_total', value=data['proxy.node.http.user_agent_total_response_bytes'], labels={'source': 'user_agent', 'protocol': 'http'}) metric.add_sample( 'trafficserver_response_size_bytes_total', value=data['proxy.node.http.origin_server_total_response_bytes'], labels={'source': 'origin_server', 'protocol': 'http'}) metric.add_sample( 'trafficserver_response_size_bytes_total', value=data['proxy.node.http.parent_proxy_total_response_bytes'], labels={'source': 'parent_proxy', 'protocol': 'http'}) yield metric # # Cache # # Gather all cache volumes for cache statistics volumes = set() for key in data: if key.startswith('proxy.process.cache.volume_'): m = CACHE_VOLUMES.match(key) volumes.add(int(m.group(1))) # Create all cache volume metrics for volume in volumes: for metric in self._parse_volume_metrics(data, volume): yield metric metric = Metric( 'trafficserver_ram_cache_hits_total', 'RAM cache hit count.', 'counter') metric.add_sample( 'trafficserver_ram_cache_hits_total', value=data['proxy.process.cache.ram_cache.hits'], labels={'volume': str(volume)}) yield metric metric = Metric( 'trafficserver_ram_cache_misses_total', 'RAM cache miss count.', 'counter') metric.add_sample( 'trafficserver_ram_cache_misses_total', value=data['proxy.process.cache.ram_cache.misses'], labels={}) yield metric metric = Metric( 'trafficserver_ram_cache_avail_size_bytes_total', 'RAM cache available in bytes.', 'gauge') metric.add_sample( 'trafficserver_ram_cache_avail_size_bytes_total', value=data['proxy.process.cache.ram_cache.total_bytes'], labels={}) yield metric metric = Metric( 'trafficserver_ram_cache_used_bytes_total', 'RAM cache used in bytes.', 'gauge') metric.add_sample( 'trafficserver_ram_cache_used_bytes_total', value=data['proxy.process.cache.ram_cache.bytes_used'], labels={}) yield metric
def collect(self): metric = Metric("nonnumber", "Non number", 'untyped') metric.add_sample("nonnumber", {}, MyNumber()) yield metric