def __init__(self, host='127.0.0.1', port=5555, transport=TCPTransport):
Handler.__init__(self)
self.client = Client(host, port, transport)
try:
conn = transport(host, port)
conn.close()
except TransportError:
raise ConnectionError("Could not connect to Riemann server.")
class RiemannHandler(Handler):
def __init__(self, host='127.0.0.1', port=5555, transport=TCPTransport):
Handler.__init__(self)
self.client = Client(host, port, transport)
try:
conn = transport(host, port)
conn.close()
except TransportError:
raise ConnectionError("Could not connect to Riemann server.")
def emit(self, record):
try:
self.client.send(record.event)
except TransportError:
raise ConnectionError("Connection to Riemann server broken.")
class RiemannHandler(Handler):
def __init__(self, host='127.0.0.1', port=5555, transport=TCPTransport):
Handler.__init__(self)
self.client = Client(host, port, transport)
try:
conn = transport(host, port)
conn.close()
except TransportError:
raise ConnectionError("Could not connect to Riemann server.")
def emit(self, record):
try:
self.client.send(record.event)
except TransportError:
raise ConnectionError("Connection to Riemann server broken.")
def __init__(self, host='127.0.0.1', port=5555, transport=TCPTransport):
Handler.__init__(self)
self.client = Client(host, port, transport)
try:
conn = transport(host, port)
conn.close()
except TransportError:
raise ConnectionError("Could not connect to Riemann server.")
def __init__(self, timeout, interval, procs, directory, host, port, limit, service_name, attributes=None):
self.timeout = timeout
self.interval = int(interval)
self.procs = str(procs).split(',')
self.directory = directory
self.host = host
self.port = port
self.limit = limit
self.syshost = socket.gethostname()
self.client = Client(self.host, int(self.port))
self.attributes = attributes
self.metric = defaultdict(lambda: 0)
self.status = dict()
self.current_status = dict()
self.data = defaultdict(list)
self.max_time_running = defaultdict(lambda: 0)
self.service_name = service_name
self.delimiter = '.' if '.' in self.service_name else '/'
from bernhard import Client, UDPTransport, TCPTransport
from bernhard import TransportError
RIEMANN_HOST = getattr(settings, 'RIEMANN_LOGGER_HOST', '127.0.0.1')
RIEMANN_PORT = getattr(settings, 'RIEMANN_LOGGER_PORT', '5555')
RIEMANN_TRANSPORT = getattr(settings, 'RIEMANN_LOGGER_TRANSPORT', 'udp')
HOST = socket.gethostname()
if RIEMANN_TRANSPORT == 'udp':
transport = UDPTransport
elif RIEMANN_TRANSPORT == 'tcp':
transport = TCPTransport
else:
raise Exception("'%s' transport unknown" % RIEMANN_TRANSPORT)
c = Client(host=RIEMANN_HOST, port=RIEMANN_PORT, transport=transport)
class RiemannHandler(logging.Handler, object):
def emit(self, record):
event = {
'host': HOST,
'service': 'django-logger',
'state': record.levelname,
'time': int(record.created),
'tags': [record.name]
}
if record.exc_info:
tb = traceback.format_exception(*record.exc_info)
event['description'] = ''.join(tb)
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
import socket
from django.conf import settings
from django.core.management.base import BaseCommand
from bernhard import Client, TCPTransport
HOST = socket.gethostname()
ENABLED = getattr(settings, 'ENABLE_METRICS', False)
RIEMANN_HOST = getattr(settings, 'RIEMANN_HOST', '127.0.0.1')
c = Client(RIEMANN_HOST, transport=TCPTransport)
def find_environment_tag():
return getattr(settings, 'INSTALLATION', None)
ENV_TAG = find_environment_tag()
def send(service, tag, metric=None):
data = {'host': HOST, 'service': service, 'tags': [tag, ENV_TAG]}
if metric:
data['metric'] = metric
class ParseToRiemann(object):
def __init__(self, timeout, interval, procs, directory, host, port, limit, service_name, attributes=None):
self.timeout = timeout
self.interval = int(interval)
self.procs = str(procs).split(',')
self.directory = directory
self.host = host
self.port = port
self.limit = limit
self.syshost = socket.gethostname()
self.client = Client(self.host, int(self.port))
self.attributes = attributes
self.metric = defaultdict(lambda: 0)
self.status = dict()
self.current_status = dict()
self.data = defaultdict(list)
self.max_time_running = defaultdict(lambda: 0)
self.service_name = service_name
self.delimiter = '.' if '.' in self.service_name else '/'
def grab(self):
if not self.directory.endswith('/*'):
self.directory += '*'
cmd = 'sv status {}'.format(self.directory)
arg = shlex.split(cmd)
arg = arg[:-1] + glob.glob(arg[-1])
return subprocess.check_output(arg).split('\n')
def parse_and_update(self):
output = self.grab()
for line in output:
try:
split_by_space = line.split()
if not split_by_space:
continue
service_name = split_by_space[1].split('/')[-1]
time_running = TIME_ALIVE_RE.findall(line)[0]
self.current_status[service_name] = split_by_space[0].startswith('run')
if service_name in self.procs or len(self.procs) <= 1:
self.data[service_name].append(int(time_running))
if time_running > self.max_time_running[service_name]:
self.max_time_running[service_name] = time_running
if len(self.data[service_name]) > self.limit:
self.data[service_name].pop()
except (KeyError, TypeError) as e:
continue
new_times_running = {k: v[-1] for k, v in self.data.iteritems()}
return new_times_running
def alive_or_dead(self):
status = dict()
for k, v in self.data.iteritems():
if not self.current_status[k]:
status[k] = False
else:
status[k] = True if len(self.data[k]) <= 1 else (self.data[k][-1] - self.data[k][-2] > self.interval - 1)
return status
def run(self):
new_times_running = self.parse_and_update()
self.status = self.alive_or_dead()
if self.status:
for k, v in self.status.iteritems():
send_service = '{service_name}{delimiter}{proc_name}'.format(service_name=self.service_name,
delimiter=self.delimiter, proc_name=k)
self.client.send(
dict(service=send_service, state='ok' if v else 'critical',
metric=new_times_running[k], host=self.syshost,
ttl=600, attributes=self.attributes))
threading.Timer(int(self.interval), self.run).start()
import logging
from flask import Flask, json, request, redirect, render_template, make_response
from shorten import UrlShortener
from functools import wraps
from bernhard import Client
from riemann_wrapper import riemann_wrapper
import urlparse
app = Flask(__name__)
shrt = UrlShortener()
logger = logging.getLogger()
logger.info("starting up")
try:
riemann_client = Client(host=config.RIEMANN_HOST,
port=config.RIEMANN_PORT)
riemann_client.send({'metric': 1,
'service':
'url-shortener.startup',
'ttl': 3600})
except:
riemann_client=None
wrap_riemann = riemann_wrapper(client=riemann_client, prefix='url-shortener.')
## template pushing routes
@app.route('/')
@wrap_riemann('home')
def index():
return render_template('index.html')
from bernhard import Client
from flask import Flask, request, redirect, make_response, json
from riemann_wrapper import riemann_wrapper
import config
from shortener import UrlShortener
app = Flask(__name__)
shorterer = UrlShortener()
logger = logging.getLogger()
logger.info("starting up")
try:
riemann_client = Client(host=config.RIEMANN_HOST, port=config.RIEMANN_PORT)
riemann_client.send({
'metric': 1,
'service': 'url-shortener.startup',
'ttl': 3600
})
except:
riemann_client = None
wrap_riemann = riemann_wrapper(client=riemann_client, prefix='url-shortener.')
@app.route('/404')
@wrap_riemann('missing', tags=['http_404'])
def missing():
response = make_response(json.dumps({"error": "not found"}))
from bernhard import Client
c = Client()
c.send({
'host': 'localhost',
'service': 'workshop startup notifier',
'state': 'success',
'tags': ['info'],
'attributes': {'clojure': 'cool'}
})
