import cloudpickle
from flask import Flask, request, jsonify, Response
import prometheus_client
from prometheus_client import Counter, Histogram
REQUEST_COUNT = Counter('request_count', 'App Request Count', [])
REQUEST_LATENCY = Histogram('request_latency_seconds', 'Request latency', [])
app = Flask(__name__)
with open('model.pkl', 'rb') as f:
model = cloudpickle.load(f)
@app.route('/predict', methods=["POST"])
@REQUEST_LATENCY.time()
def predict():
REQUEST_COUNT.inc()
req = request.json
print(req)
return jsonify(model.predict(req))
CONTENT_TYPE_LATEST = str('text/plain; version=0.0.4; charset=utf-8')
@app.route('/metrics', methods=["GET"])
def metrics():
return Response(prometheus_client.generate_latest(),
mimetype=CONTENT_TYPE_LATEST)
PersistedEventPosition,
RoomStreamToken,
StreamKeyType,
StreamToken,
UserID,
)
from synapse.util.async_helpers import ObservableDeferred, timeout_deferred
from synapse.util.metrics import Measure
from synapse.visibility import filter_events_for_client
if TYPE_CHECKING:
from synapse.server import HomeServer
logger = logging.getLogger(__name__)
notified_events_counter = Counter("synapse_notifier_notified_events", "")
users_woken_by_stream_counter = Counter(
"synapse_notifier_users_woken_by_stream", "", ["stream"])
T = TypeVar("T")
# TODO(paul): Should be shared somewhere
def count(func: Callable[[T], bool], it: Iterable[T]) -> int:
"""Return the number of items in it for which func returns true."""
n = 0
for x in it:
if func(x):
n += 1
return n
import requests
import json
import datetime
from flask import Flask, Response, jsonify
from flask_apscheduler import APScheduler
from werkzeug.middleware.dispatcher import DispatcherMiddleware
from prometheus_client import make_wsgi_app, Counter, Gauge
app = Flask(__name__)
app.wsgi_app = DispatcherMiddleware(app.wsgi_app,
{'/metrics': make_wsgi_app()})
count = Counter('counter', 'Count of requests')
block = Gauge('latest_block', 'Bitcoin latest block')
price = Gauge('latest_price', 'Bitcoin latest price')
volume = Gauge('trade_volume', 'Estimated transaction volume (BTC)')
@app.route('/')
def hello_world():
r = requests.get('https://api.blockchain.info/stats')
response = r.json()
latest_block = response['n_blocks_total']
block.set(latest_block)
latest_price = response['market_price_usd']
price.set(latest_price)
trade_volume = response['trade_volume_btc']
volume.set(trade_volume)
user.add_metric([], float(raw_stats[11]) / self.ticks_per_sec)
yield user
sys = GaugeMetricFamily("process_cpu_system_seconds_total", "")
sys.add_metric([], float(raw_stats[12]) / self.ticks_per_sec)
yield sys
REGISTRY.register(CPUMetrics())
#
# Federation Metrics
#
sent_transactions_counter = Counter("synapse_federation_client_sent_transactions", "")
events_processed_counter = Counter("synapse_federation_client_events_processed", "")
event_processing_loop_counter = Counter(
"synapse_event_processing_loop_count", "Event processing loop iterations", ["name"]
)
event_processing_loop_room_count = Counter(
"synapse_event_processing_loop_room_count",
"Rooms seen per event processing loop iteration",
["name"],
)
# Used to track where various components have processed in the event stream,
import time
import prometheus_client
from prometheus_client.core import CollectorRegistry
from prometheus_client import Summary, Counter, Histogram, Gauge
_INF = float("inf")
graphs = {}
graphs['c'] = Counter('python_request_operations_total',
'The total number of processed requests')
graphs['h'] = Histogram('python_request_duration_seconds',
'Histogram for the duration in seconds.',
buckets=(1, 2, 5, 6, 10, _INF))
def count_process():
start = time.time()
graphs['c'].inc()
time.sleep(0.600)
end = time.time()
graphs['h'].observe(end - start)
RequestSendFailed,
)
from synapse.events import EventBase
from synapse.federation.units import Edu
from synapse.handlers.presence import format_user_presence_state
from synapse.metrics import sent_transactions_counter
from synapse.metrics.background_process_metrics import run_as_background_process
from synapse.storage import UserPresenceState
from synapse.util.retryutils import NotRetryingDestination, get_retry_limiter
# This is defined in the Matrix spec and enforced by the receiver.
MAX_EDUS_PER_TRANSACTION = 100
logger = logging.getLogger(__name__)
sent_edus_counter = Counter("synapse_federation_client_sent_edus",
"Total number of EDUs successfully sent")
sent_edus_by_type = Counter(
"synapse_federation_client_sent_edus_by_type",
"Number of sent EDUs successfully sent, by event type",
["type"],
)
class PerDestinationQueue(object):
"""
Manages the per-destination transmission queues.
Args:
hs (synapse.HomeServer):
transaction_sender (TransactionManager):
from synapse.replication.http.federation import (
ReplicationFederationSendEduRestServlet,
ReplicationGetQueryRestServlet,
)
from synapse.types import get_domain_from_id
from synapse.util import glob_to_regex
from synapse.util.async_helpers import Linearizer, concurrently_execute
from synapse.util.caches.response_cache import ResponseCache
# when processing incoming transactions, we try to handle multiple rooms in
# parallel, up to this limit.
TRANSACTION_CONCURRENCY_LIMIT = 10
logger = logging.getLogger(__name__)
received_pdus_counter = Counter("synapse_federation_server_received_pdus", "")
received_edus_counter = Counter("synapse_federation_server_received_edus", "")
received_queries_counter = Counter(
"synapse_federation_server_received_queries", "", ["type"])
class FederationServer(FederationBase):
def __init__(self, hs):
super(FederationServer, self).__init__(hs)
self.auth = hs.get_auth()
self.handler = hs.get_handlers().federation_handler
self._server_linearizer = Linearizer("fed_server")
import grpc
import greeter_pb2_grpc
import greeter_pb2
import prometheus_client
from prometheus_client import Counter
from flask import Response, Flask, request, make_response
from interceptor import header_adder_interceptor
from log import init_log
init_log()
app = Flask(__name__)
requests_total = Counter("request_count", "Total request cout of the host")
channel = grpc.insecure_channel('test-greeter:50051')
header_interceptor = header_adder_interceptor(request)
intercept_channel = grpc.intercept_channel(channel, header_interceptor)
greeter_client = greeter_pb2_grpc.GreeterStub(intercept_channel)
retry_count = {}
@app.route("/metrics")
def requests_count():
return Response(prometheus_client.generate_latest(requests_total),
mimetype="text/plain")
from rucio.daemons.conveyor.common import submit_transfer, bulk_group_transfer, get_conveyor_rses, USER_ACTIVITY
from rucio.db.sqla.constants import RequestState
try:
from ConfigParser import NoOptionError # py2
except Exception:
from configparser import NoOptionError # py3
graceful_stop = threading.Event()
USER_TRANSFERS = config_get('conveyor', 'user_transfers', False, None)
TRANSFER_TOOL = config_get('conveyor', 'transfertool', False, None)
TRANSFER_TYPE = config_get('conveyor', 'transfertype', False, 'single')
GET_TRANSFERS_COUNTER = Counter(
'rucio_daemons_conveyor_submitter_get_transfers',
'Number of transfers retrieved')
def submitter(once=False,
rses=None,
mock=False,
bulk=100,
group_bulk=1,
group_policy='rule',
source_strategy=None,
activities=None,
sleep_time=600,
max_sources=4,
retry_other_fts=False):
"""
from flask import request, redirect
from sqlalchemy import or_, func
from sqlalchemy.exc import IntegrityError
from algoliasearch.exceptions import AlgoliaUnreachableHostException, AlgoliaException
from app.api import bp
from app.api.auth import is_user_oc_member, authenticate
from app.api.validations import validate_resource, requires_body
from app.models import Language, Resource, Category, Key
from app import Config, db, index
from dateutil import parser
from datetime import datetime
from prometheus_client import Counter, Summary
import app.utils as utils
# Metrics
failures_counter = Counter('my_failures', 'Number of exceptions raised')
latency_summary = Summary('request_latency_seconds', 'Length of request')
logger = utils.setup_logger('routes_logger')
# Routes
@latency_summary.time()
@failures_counter.count_exceptions()
@bp.route('/resources', methods=['GET'], endpoint='get_resources')
def resources():
return get_resources()
@latency_summary.time()
@failures_counter.count_exceptions()
COMMAND_MAP,
VALID_CLIENT_COMMANDS,
VALID_SERVER_COMMANDS,
ErrorCommand,
NameCommand,
PingCommand,
PositionCommand,
RdataCommand,
ReplicateCommand,
ServerCommand,
SyncCommand,
UserSyncCommand,
)
from .streams import STREAMS_MAP
connection_close_counter = Counter(
"synapse_replication_tcp_protocol_close_reason", "", ["reason_type"])
# A list of all connected protocols. This allows us to send metrics about the
# connections.
connected_connections = []
logger = logging.getLogger(__name__)
PING_TIME = 5000
PING_TIMEOUT_MULTIPLIER = 5
PING_TIMEOUT_MS = PING_TIME * PING_TIMEOUT_MULTIPLIER
class ConnectionStates(object):
from insert_realtime_data.src.crawl_one_minute_stick import run as stick_run
from insert_realtime_data.src.crawl_five_minutes_exchange import run as exchange_run
from insert_realtime_data.src.crawl_brokers import run as broker_exchange_run
from insert_realtime_data.src.crawl_cmoney import run as cmoney_run
tpe = pytz.timezone('Asia/Taipei')
scheduler = AsyncIOScheduler()
collectors = list(REGISTRY._collector_to_names.keys())
for collector in collectors:
REGISTRY.unregister(collector)
total_one_minute_stick = Counter('crawl_one_minute_k_stick', 'Total one minute k stick count')
total_five_seconds_exchange = Counter('crawl_five_seconds_exchange', 'Total five seconds exchange')
total_brokers_exchange = Counter('crawl_brokers', 'Total brokers')
total_tradersum = Counter('total_tradersum', 'crawl total_tradersum')
total_stock_info = Counter('total_stock_info', 'crawl total_stock_info')
total_stock_revenue = Counter('total_stock_revenue', 'crawl total_stock_revenue')
total_reinvestment = Counter('total_reinvestment', 'crawl total_reinvestment')
total_per_pbr = Counter('total_per_pbr', 'crawl total_per_pbr')
total_balance_sheet = Counter('total_balance_sheet', 'crawl total_balance_sheet')
total_income_statement = Counter('total_income_statement', 'crawl total_income_statement')
total_cash_flow = Counter('total_cash_flow', 'crawl total_cash_flow')
total_financial_ratios = Counter('total_financial_ratios', 'crawl total_financial_ratios')
def get_application():
_app = FastAPI(title=settings.PROJECT_NAME, openapi_url=f'{settings.API_V1_STR}/openapi.json')
from synapse.metrics.background_process_metrics import (
run_as_background_process,
wrap_as_background_process,
)
from synapse.types import JsonDict, ReadReceipt, RoomStreamToken
from synapse.util import Clock
from synapse.util.metrics import Measure
if TYPE_CHECKING:
from synapse.events.presence_router import PresenceRouter
from synapse.server import HomeServer
logger = logging.getLogger(__name__)
sent_pdus_destination_dist_count = Counter(
"synapse_federation_client_sent_pdu_destinations:count",
"Number of PDUs queued for sending to one or more destinations",
)
sent_pdus_destination_dist_total = Counter(
"synapse_federation_client_sent_pdu_destinations:total",
"Total number of PDUs queued for sending across all destinations",
)
# Time (in s) after Synapse's startup that we will begin to wake up destinations
# that have catch-up outstanding.
CATCH_UP_STARTUP_DELAY_SEC = 15
# Time (in s) to wait in between waking up each destination, i.e. one destination
# will be woken up every <x> seconds after Synapse's startup until we have woken
# every destination has outstanding catch-up.
CATCH_UP_STARTUP_INTERVAL_SEC = 5
'--tz', dest='tz',
help="Timezone used by the celery app."
)
parser.add_argument(
'--queue',
dest='queues',
action='append',
help='Celery queues to check length for'
)
# We have these counters because sometimes we might not
# be able to find out the queue time or runtime of a task,
# so we can't mark an observation in the histogram
task_submissions = Counter(
'celery_task_submissions',
'number of times a task has been submitted',
['task_name', 'exchange'],
)
task_completions = Counter(
'celery_task_completions',
'number of times a task has been completed',
['task_name', 'state', 'exchange'],
)
task_queuetime_seconds = Histogram(
'celery_task_queuetime_seconds',
'number of seconds spent in queue for celery tasks',
['task_name', 'exchange'],
buckets=(
.005, .01, .025, .05, .075, .1, .25, .5,
.75, 1.0, 2.5, 5.0, 7.5, 10.0, 100.0, float('inf')
)
from typing import Any, Callable, Optional, Type, TypeVar, cast
from prometheus_client import Counter
from typing_extensions import Protocol
from synapse.logging.context import (
ContextResourceUsage,
LoggingContext,
current_context,
)
from synapse.metrics import InFlightGauge
from synapse.util import Clock
logger = logging.getLogger(__name__)
block_counter = Counter("synapse_util_metrics_block_count", "", ["block_name"])
block_timer = Counter("synapse_util_metrics_block_time_seconds", "",
["block_name"])
block_ru_utime = Counter("synapse_util_metrics_block_ru_utime_seconds", "",
["block_name"])
block_ru_stime = Counter("synapse_util_metrics_block_ru_stime_seconds", "",
["block_name"])
block_db_txn_count = Counter("synapse_util_metrics_block_db_txn_count", "",
["block_name"])
# seconds spent waiting for db txns, excluding scheduling time, in this block
block_db_txn_duration = Counter(
def test_counter(self):
c = Counter('cc', 'A counter', registry=self.registry)
c.inc()
self.assertEqual(b'# HELP cc A counter\n# TYPE cc counter\ncc 1.0\n',
generate_latest(self.registry))
class Stats(object):
metrics_label_names = [
'tenant', 'namespace', 'function', 'instance_id', 'cluster'
]
TOTAL_PROCESSED = 'pulsar_function_processed_total'
TOTAL_SUCCESSFULLY_PROCESSED = 'pulsar_function_processed_successfully_total'
TOTAL_SYSTEM_EXCEPTIONS = 'pulsar_function_system_exceptions_total'
TOTAL_USER_EXCEPTIONS = 'pulsar_function_user_exceptions_total'
PROCESS_LATENCY_MS = 'pulsar_function_process_latency_ms'
LAST_INVOCATION = 'pulsar_function_last_invocation'
TOTAL_RECEIVED = 'pulsar_function_received_total'
# Declare Prometheus
stat_total_processed = Counter(TOTAL_PROCESSED,
'Total number of messages processed.',
metrics_label_names)
stat_total_processed_successfully = Counter(
TOTAL_SUCCESSFULLY_PROCESSED,
'Total number of messages processed successfully.',
metrics_label_names)
stat_total_sys_exceptions = Counter(TOTAL_SYSTEM_EXCEPTIONS,
'Total number of system exceptions.',
metrics_label_names)
stat_total_user_exceptions = Counter(TOTAL_USER_EXCEPTIONS,
'Total number of user exceptions.',
metrics_label_names)
stat_process_latency_ms = Summary(PROCESS_LATENCY_MS,
'Process latency in milliseconds.',
metrics_label_names)
stat_last_invocation = Gauge(
LAST_INVOCATION,
'The timestamp of the last invocation of the function.',
metrics_label_names)
stat_total_received = Counter(
TOTAL_RECEIVED, 'Total number of messages received from source.',
metrics_label_names)
latest_user_exception = []
latest_sys_exception = []
def add_user_exception(self):
self.latest_sys_exception.append(
(traceback.format_exc(), int(time.time() * 1000)))
if len(self.latest_sys_exception) > 10:
self.latest_sys_exception.pop(0)
def add_sys_exception(self):
self.latest_sys_exception.append(
(traceback.format_exc(), int(time.time() * 1000)))
if len(self.latest_sys_exception) > 10:
self.latest_sys_exception.pop(0)
def reset(self, metrics_labels):
self.latest_user_exception = []
self.latest_sys_exception = []
self.stat_total_processed.labels(*metrics_labels)._value.set(0.0)
self.stat_total_processed_successfully.labels(
*metrics_labels)._value.set(0.0)
self.stat_total_user_exceptions.labels(*metrics_labels)._value.set(0.0)
self.stat_total_sys_exceptions.labels(*metrics_labels)._value.set(0.0)
self.stat_process_latency_ms.labels(*metrics_labels)._sum.set(0.0)
self.stat_process_latency_ms.labels(*metrics_labels)._count.set(0.0)
self.stat_last_invocation.labels(*metrics_labels).set(0.0)
self.stat_total_received.labels(*metrics_labels)._value.set(0.0)
def test_unicode(self):
c = Counter('cc', '\u4500', ['l'], registry=self.registry)
c.labels('\u4500').inc()
self.assertEqual(
b'# HELP cc \xe4\x94\x80\n# TYPE cc counter\ncc{l="\xe4\x94\x80"} 1.0\n',
generate_latest(self.registry))
MEM_TOTAL = Gauge('mem_total', 'memory total')
MEM_AVAILABLE = Gauge('mem_available', 'memory available')
MEM_USED = Gauge('mem_used', 'memory used')
MEM_FREE = Gauge('mem_free', 'memory free')
DISK_PERCENT = Gauge(
'disk_percent', 'Percent of disk space used for the '
'volume mounted at root')
BYTES_SENT = Gauge('bytes_sent', 'System-wide network I/O bytes sent')
BYTES_RECEIVED = Gauge('bytes_received',
'System-wide network I/O bytes received')
TEMPERATURE = Gauge('temperature', 'Temperature readings from system sensors',
['sensor'])
CHECKIN_STATUS = Gauge('checkin_status',
'1 for checkin success, and 0 for failure')
BOOTSTRAP_EXCEPTION = Counter('bootstrap_exception',
'Count for exceptions raised by bootstrapper',
['cause'])
UNEXPECTED_SERVICE_RESTARTS = Counter('unexpected_service_restarts',
'Count of unexpected restarts',
['service_name'])
UNATTENDED_UPGRADE_STATUS = Gauge(
'unattended_upgrade_status', 'Unattended Upgrade update status'
'1 for active, 0 for inactive')
SERVICE_RESTART_STATUS = Counter('service_restart_status',
'Count of service restarts',
['service_name', 'status'])
def _get_ping_params(config):
ping_params = []
def test_escaping(self):
c = Counter('cc', 'A\ncount\\er', ['a'], registry=self.registry)
c.labels('\\x\n"').inc(1)
self.assertEqual(
b'# HELP cc A\\ncount\\\\er\n# TYPE cc counter\ncc{a="\\\\x\\n\\""} 1.0\n',
generate_latest(self.registry))
from prometheus_client import Gauge, Info, Counter
GROW_INFO = Info('growing', 'Grow info')
AIR_TEMPERATURE = Gauge('air_temperature', 'Air temperature')
AIR_HUMIDITY = Gauge('air_humidity', 'Air humidity')
WATER_LEVEL = Gauge('water_level', 'Water level')
PI_TEMPERATURE = Gauge('pi_temperature', 'Raspberry PI CPU temperature')
LIGHT_BRIGHTNESS = Gauge('light_brightness', 'Light brightness')
FAN_SPEED = Gauge('fan_speed', 'Fan speed')
TARGET_TEMPERATURE = Gauge('target_temperature', 'Target temperature')
TARGET_HUMIDITY = Gauge('target_humidity', 'Target humidity')
HUMIDIFIER_USAGE = Counter('humidifier_usage', 'Humidifier usage')
OUTSIDE_AIR_TEMPERATURE = Gauge('outside_air_temperature',
'Outside air temperature')
OUTSIDE_AIR_HUMIDITY = Gauge('outside_air_humidity', 'Outside air humidity')
from synapse.util.async_helpers import Linearizer
from synapse.util.caches import CacheMetric, register_cache
from synapse.util.caches.descriptors import lru_cache
from synapse.util.caches.lrucache import LruCache
from synapse.util.metrics import measure_func
from ..storage.state import StateFilter
from .push_rule_evaluator import PushRuleEvaluatorForEvent
if TYPE_CHECKING:
from synapse.server import HomeServer
logger = logging.getLogger(__name__)
push_rules_invalidation_counter = Counter(
"synapse_push_bulk_push_rule_evaluator_push_rules_invalidation_counter",
"")
push_rules_state_size_counter = Counter(
"synapse_push_bulk_push_rule_evaluator_push_rules_state_size_counter", "")
# Measures whether we use the fast path of using state deltas, or if we have to
# recalculate from scratch
push_rules_delta_state_cache_metric = register_cache(
"cache",
"push_rules_delta_state_cache_metric",
cache=[], # Meaningless size, as this isn't a cache that stores values
resizable=False,
)
STATE_EVENT_TYPES_TO_MARK_UNREAD = {
EventTypes.Topic,
def _counter(self, var, var_help, labels):
return Counter(var, var_help, labels, registry=self._reg) # pylint: disable=unexpected-keyword-arg
app = Flask('__main__')
app.logger.setLevel(logging.INFO)
CART = os.getenv('CART_HOST', 'cart')
USER = os.getenv('USER_HOST', 'user')
CART_URL = 'http://' + CART + ':8080'
CART_URL = 'https://172.17.0.1/api/v1/web/guest/robotshop/cart'
USER_URL = 'http://' + USER + ':8080'
USER_URL = 'https://172.17.0.1/api/v1/web/guest/robotshop/user'
os.environ['SHOP_PAYMENT_PORT'] = '8082'
PAYMENT_GATEWAY = os.getenv('PAYMENT_GATEWAY', 'https://paypal.com/')
# Prometheus
PromMetrics = {}
PromMetrics['SOLD_COUNTER'] = Counter('sold_count',
'Running count of items sold')
PromMetrics['AUS'] = Histogram('units_sold',
'Avergae Unit Sale',
buckets=(1, 2, 5, 10, 100))
PromMetrics['AVS'] = Histogram('cart_value',
'Avergae Value Sale',
buckets=(100, 200, 500, 1000, 2000, 5000,
10000))
@app.errorhandler(Exception)
def exception_handler(err):
app.logger.error(str(err))
return str(err), 500
import cgi
import simplejson as json
import logging
import random
import sys
import urllib
from six.moves.urllib import parse as urlparse
from six import string_types
from prometheus_client import Counter
logger = logging.getLogger(__name__)
outbound_logger = logging.getLogger("synapse.http.outbound")
outgoing_requests_counter = Counter(
"synapse_http_matrixfederationclient_requests", "", ["method"])
incoming_responses_counter = Counter(
"synapse_http_matrixfederationclient_responses", "", ["method", "code"])
MAX_LONG_RETRIES = 10
MAX_SHORT_RETRIES = 3
class MatrixFederationEndpointFactory(object):
def __init__(self, hs):
self.tls_server_context_factory = hs.tls_server_context_factory
def endpointForURI(self, uri):
destination = uri.netloc
return matrix_federation_endpoint(
def export_defaults(self,
buckets=None,
group_by='path',
prefix='flask',
app=None,
**kwargs):
"""
Export the default metrics:
- HTTP request latencies
- Number of HTTP requests
:param buckets: the time buckets for request latencies
(will use the default when `None`)
:param group_by: group default HTTP metrics by
this request property, like `path`, `endpoint`, `rule`, etc.
(defaults to `path`)
:param prefix: prefix to start the default metrics names with
or `NO_PREFIX` (to skip prefix)
:param app: the Flask application
"""
if app is None:
app = self.app or current_app
if not prefix:
prefix = self._defaults_prefix or 'flask'
# use the default buckets from prometheus_client if not given here
buckets_as_kwargs = {}
if buckets is not None:
buckets_as_kwargs['buckets'] = buckets
if kwargs.get('group_by_endpoint') is True:
warnings.warn(
'The `group_by_endpoint` argument of '
'`PrometheusMetrics.export_defaults` is deprecated since 0.4.0, '
'please use the new `group_by` argument.', DeprecationWarning)
duration_group = 'endpoint'
elif group_by:
duration_group = group_by
else:
duration_group = 'path'
if callable(duration_group):
duration_group_name = duration_group.__name__
else:
duration_group_name = duration_group
if prefix == NO_PREFIX:
prefix = ""
else:
prefix = prefix + "_"
additional_labels = self._static_labels.items()
histogram = Histogram('%shttp_request_duration_seconds' % prefix,
'Flask HTTP request duration in seconds',
('method', duration_group_name, 'status') +
tuple(map(lambda kv: kv[0], additional_labels)),
registry=self.registry,
**buckets_as_kwargs)
counter = Counter('%shttp_request_total' % prefix,
'Total number of HTTP requests',
('method', 'status') +
tuple(map(lambda kv: kv[0], additional_labels)),
registry=self.registry)
self.info('%sexporter_info' % prefix,
'Information about the Prometheus Flask exporter',
version=self.version,
**self._static_labels)
def before_request():
request.prom_start_time = default_timer()
def after_request(response):
if hasattr(request, 'prom_do_not_track'):
return response
if hasattr(request, 'prom_start_time'):
total_time = max(default_timer() - request.prom_start_time, 0)
if callable(duration_group):
group = duration_group(request)
else:
group = getattr(request, duration_group)
histogram.labels(request.method, group, response.status_code,
*map(lambda kv: kv[1],
additional_labels)).observe(total_time)
counter.labels(request.method, response.status_code,
*map(lambda kv: kv[1], additional_labels)).inc()
return response
app.before_request(before_request)
app.after_request(after_request)
This source code is licensed under the BSD-style license found in the
LICENSE file in the root directory of this source tree.
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
from prometheus_client import Counter, Histogram
# Counters for Diameter/S6a application
S6A_AUTH_SUCCESS_TOTAL = Counter(
's6a_auth_success',
'Total successful S6a auth requests',
)
S6A_AUTH_FAILURE_TOTAL = Counter(
's6a_auth_failure',
'Total failed S6a auth requests with reason',
['code'],
)
S6A_LUR_TOTAL = Counter(
's6a_location_update',
'Total S6a location update requests',
)
DIAMETER_AUTHENTICATION_REJECTED = 4001
DIAMETER_ERROR_USER_UNKNOWN = 5001
DIAMETER_AUTHORIZATION_REJECTED = 5003
# Counters for Diameter base application
# Set environment variables
REDIS_HOST = os.environ['REDIS_HOST']
REDIS_PASSWORD = os.environ['REDIS_PASSWORD']
app = Flask(__name__)
# intialize logger
json_logging.init_flask(enable_json=True)
json_logging.init_request_instrument(app)
logger = logging.getLogger("flask-counter")
logger.setLevel(logging.DEBUG)
logger.addHandler(logging.StreamHandler(sys.stdout))
cache = redis.Redis(host=REDIS_HOST, port=6379, password=REDIS_PASSWORD)
c = Counter("redis_calls", "Number of calls to redis", ["status"])
def get_hit_count():
retries = 5
while True:
try:
hits = cache.incr('hits')
c.labels(status="success").inc()
return hits
except redis.exceptions.ConnectionError as exc:
if retries == 0:
c.labels(status="failure").inc()
raise exc
retries -= 1
time.sleep(0.5)
"""Som Model Adapter - Working with custom implementation of SOM."""
import logging
import uuid
import numpy as np
from anomaly_detector.adapters import BaseModelAdapter
from anomaly_detector.decorator.utils import latency_logger
from anomaly_detector.exception import ModelLoadException, ModelSaveException
from anomaly_detector.model import SOMPYModel, W2VModel
import os
from prometheus_client import Gauge, Counter, Histogram
from urllib.parse import quote
ANOMALY_COUNT = Gauge("aiops_lad_anomaly_count", "count of anomalies runs", ['anomaly_status'])
ANOMALY_SCORE = Gauge("aiops_lad_anomaly_avg_score", "avg anomaly score")
LOG_LINES_COUNT = Gauge("aiops_lad_loglines_count", "count of log lines processed runs")
FALSE_POSITIVE_COUNT = Counter("aiops_lad_false_positive_count", "count of false positives processed runs", ['id'])
ANOMALY_HIST = Histogram("aiops_hist", "histogram of anomalies runs")
THRESHOLD = Gauge("aiops_lad_threshold", "Threshold of marker for anomaly")
class SomModelAdapter(BaseModelAdapter):
"""Self organizing map custom logic to train model. Includes logic to train and predict anomalies in logs."""
def __init__(self, storage_adapter):
"""Init storage provider which provides config and storage interface with storage systems."""
self.storage_adapter = storage_adapter
update_model = self.storage_adapter.TRAIN_UPDATE_MODEL
self.update_model = os.path.isfile(self.storage_adapter.MODEL_PATH) and update_model
self.update_w2v_model = os.path.isfile(self.storage_adapter.W2V_MODEL_PATH) and update_model
self.recreate_models = False
self.model = SOMPYModel(config=storage_adapter.config)
from prometheus_client import Counter
counter_one = Counter('arbitrary_counter_one',
'number of times button clicked')
counter_two = Counter('arbitrary_counter_two',
'number of times button clicked time two')
def increment_counter_one():
counter_one.inc()
def get_current_counter_one_value():
return counter_one._value.get()
def increment_counter_two():
counter_two.inc(2)
def get_current_counter_two_value():
return counter_two._value.get()
