def get_utc_day_times(target_tz, target_datetime):
utc_start_of_day = target_tz.localize(datetime(target_datetime.year,
target_datetime.month,
target_datetime.day, 0, 0)).astimezone(pytz.UTC)
utc_end_of_day = target_tz.localize(datetime(target_datetime.year,
target_datetime.month,
target_datetime.day, 23, 59)).astimezone(pytz.UTC)
return datetime_to_ts(utc_start_of_day), datetime_to_ts(utc_end_of_day)
def generate(self, monitor, target_tz, date_for):
start = datefromiso(date_for).replace(day=1)
today = datetime.now(tz=utc).astimezone(target_tz).date()
# depending whether the report is for the current month or one
# of the past months, the end date for report might be
# the last day of some (past) month, or today
if today.year == start.year and today.month == start.month:
end = today
else:
_, last_day = calendar.monthrange(start.year, start.month)
end = date(start.year, start.month, last_day)
facet_names = [item['facet'] for item in self.report_plan if item.has_key('facet')]
facets = self.session.query(Facet).filter(Facet.kind==monitor.kind).all()
hist_facets = []
for facet in facets:
for hist_facet_name, hist_facet in facet.hist.items():
if hist_facet_name in facet_names:
hist_facets.append(hist_facet)
hist_facet_ids = []
hist_facet_by_id = dict()
for hist_facet in hist_facets:
hist_facet_ids.append(hist_facet.hist_facet_id)
hist_facet_by_id[hist_facet.hist_facet_id] = hist_facet
pre_result = dict()
# get facets
query = select([t_monitor_log_hist.c.hist_facet_id, t_monitor_log_hist.c.ts, t_monitor_log_hist.c.node, t_monitor_log_hist.c.value],
and_(t_monitor_log_hist.c.monitor_id==monitor.monitor_id,
t_monitor_log_hist.c.hist_facet_id.in_(hist_facet_ids),
t_monitor_log_hist.c.ts >= datetime_to_ts(start),
t_monitor_log_hist.c.ts <= datetime_to_ts(end)))
for hist_facet_id, ts, node, value in self.session.execute(query):
hist_facet = hist_facet_by_id[hist_facet_id]
pre_result.setdefault(ts, dict())[hist_facet.name] = value
if node is not None:
pre_result.setdefault(ts, dict())['node'] = node
result = []
sorted_ts = pre_result.keys()
sorted_ts.sort()
for ts in sorted_ts:
data = pre_result[ts]
data['ts'] = ts
result.append(data)
return [self.report_plan, result]
def generate(self, monitor, target_tz, date_for):
start = utcdatetimefromiso(date_for, target_tz)
end = start + timedelta(days=1)
facet_names = [item['facet'] for item in self.report_plan if item.has_key('facet')]
facets = self.session.query(Facet).filter(Facet.kind==monitor.kind).filter(Facet.name.in_(facet_names)).all()
facet_ids = []
facet_by_id = dict()
for facet in facets:
facet_ids.append(facet.facet_id)
facet_by_id[facet.facet_id] = facet
pre_result = dict()
# get facets
query = select([t_monitor_log.c.facet_id, t_monitor_log.c.ts, t_monitor_log.c.node, t_monitor_log.c.value],
and_(t_monitor_log.c.monitor_id==monitor.monitor_id,
t_monitor_log.c.facet_id.in_(facet_ids),
t_monitor_log.c.ts >= datetime_to_ts(start),
t_monitor_log.c.ts < datetime_to_ts(end)))
for facet_id, ts, node, value in self.session.execute(query):
facet = facet_by_id[facet_id]
pre_result.setdefault(ts, dict())[facet.name] = value
if node is not None:
pre_result.setdefault(ts, dict())['node'] = node
# get errors
query = select([t_error_log.c.ts, t_error_log.c.node, t_error_log.c.error],
and_(t_error_log.c.monitor_id==monitor.monitor_id,
t_error_log.c.ts >= datetime_to_ts(start),
t_error_log.c.ts < datetime_to_ts(end)))
for ts, node, err in self.session.execute(query):
pre_result.setdefault(ts, dict())['error'] = err
result = []
sorted_ts = pre_result.keys()
sorted_ts.sort()
for ts in sorted_ts:
data = pre_result[ts]
data['ts'] = long(datetime_to_ts(ts_to_datetime(ts).astimezone(target_tz)))
result.append(data)
return [self.report_plan, result]
def hist_stats_for_user(session, user_id, days_back=1):
user = session.query(User).get(user_id)
log.debug("Doing stats for user %s", user.email)
target_tz = pytz.timezone(user.timezone)
target_datetime = datetime.now(tz=target_tz) - timedelta(days=days_back)
target_datetime_ts = datetime_to_ts(datetime(target_datetime.year, target_datetime.month, target_datetime.day, 0, 0))
ts_day_start, ts_day_end = get_utc_day_times(target_tz, target_datetime)
for monitor in user.monitors.values():
hist_stats_for_monitor(session, monitor, target_datetime_ts, ts_day_start, ts_day_end)
# update UTC offset
user.utc_offset = get_utc_offset(pytz.timezone(user.timezone))
session.flush()
def daily_stats(self, r, name):
target_tz = pytz.timezone(r.user.timezone)
now = datetime.utcnow()
monitor = r.user.monitors[name]
facet_name_by_kind = {
Monitor.KIND_HTTP: 'time',
Monitor.KIND_HTTPS: 'time',
Monitor.KIND_PING: 'rtt_avg',
Monitor.KIND_DNS: 'time',
}
facet_name = facet_name_by_kind[monitor.kind]
facet = r.session.query(Facet).filter_by(kind=monitor.kind, name=facet_name).one()
query = select([t_monitor_log.c.ts, t_monitor_log.c.node, t_monitor_log.c.value],
and_(t_monitor_log.c.facet_id == facet.facet_id,
t_monitor_log.c.monitor_id == monitor.monitor_id,
t_monitor_log.c.ts > datetime_to_ts(now - timedelta(days=1))))
query = query.order_by(t_monitor_log.c.ts.desc())
if monitor.kind in [Monitor.KIND_HTTP, Monitor.KIND_HTTPS]:
title = "Response time and availability for last 24 hours"
elif monitor.kind == Monitor.KIND_PING:
title = "Round trip time and availability for last 24 hours"
else:
title = "Unknown"
all_series = [dict(title=title),
[dict(legend='Missouri, US')],
[dict(legend='Georgia, US')],
[dict(legend='London, UK')],
]
result = r.session.execute(query)
for ts, node, value in result:
all_series[node].append(datetime_to_ts(ts_to_datetime(ts).astimezone(target_tz)))
all_series[node].append(value)
return all_series
def hist_stats_for_monitor(session, monitor, target_datetime_ts, ts_day_start, ts_day_end):
log.debug("Monitor %s", monitor.name)
facets = session.query(Facet).filter_by(kind=monitor.kind).all()
for facet in facets:
for hfacet in facet.hist.values():
result = HIST_AGG_MAP[hfacet.agg_type](session, monitor, facet, ts_day_start, ts_day_end)
t_monitor_log_hist.insert().execute(monitor_id = monitor.monitor_id,
hist_facet_id = hfacet.hist_facet_id,
node = 0,
ts = target_datetime_ts,
value = result)
# delete entries older than 14 days from monitor_log and ping_log
q = t_monitor_log.delete(and_(t_monitor_log.c.ts < datetime_to_ts(datetime.utcnow().date() - timedelta(days=14)),
t_monitor_log.c.monitor_id == monitor.monitor_id))
session.execute(q)
