google_appengine/google/appengine/ext/ereporter/report_generator.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright 2007 Google Inc.
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16 #
  17
  18 """Generates and emails daily exception reports.
  19
  20 See google/appengine/ext/ereporter/__init__.py for usage details.
  21
  22 Valid query string arguments to the report_generator script include:
  23 delete:   Set to 'false' to prevent deletion of exception records from the
  24           datastore after sending a report. Defaults to 'true'.
  25 debug:    Set to 'true' to return the report in the response instead of
  26           emailing it.
  27 date:     The date to generate the report for, in yyyy-mm-dd format. Defaults to
  28           yesterday's date. Useful for debugging.
  29 max_results: Maximum number of entries to include in a report.
  30 sender:   The email address to use as the sender. Must be an administrator.
  31 to:       If specified, send reports to this address. If not specified, all
  32           admins are sent the report.
  33 versions: 'all' to report on all minor versions, or 'latest' for the latest.
  34 """
  35
  36
  37
  38
  39
  40 import datetime
  41 import itertools
  42 import os
  43 import re
  44 from xml.sax import saxutils
  45
  46 from google.appengine.api import mail
  47 from google.appengine.ext import db
  48 from google.appengine.ext import ereporter
  49 from google.appengine.ext import webapp
  50 from google.appengine.ext.webapp import template
  51 from google.appengine.ext.webapp.util import run_wsgi_app
  52
  53
  54 def isTrue(val):
  55   """Determines if a textual value represents 'true'.
  56
  57   Args:
  58     val: A string, which may be 'true', 'yes', 't', '1' to indicate True.
  59   Returns:
  60     True or False
  61   """
  62   val = val.lower()
  63   return val == 'true' or val == 't' or val == '1' or val == 'yes'
  64
  65
  66 class ReportGenerator(webapp.RequestHandler):
  67   """Handler class to generate and email an exception report."""
  68
  69   DEFAULT_MAX_RESULTS = 100
  70
  71   def __init__(self, send_mail=mail.send_mail,
  72                mail_admins=mail.send_mail_to_admins):
  73     super(ReportGenerator, self).__init__()
  74
  75     self.send_mail = send_mail
  76     self.send_mail_to_admins = mail_admins
  77
  78   def GetQuery(self, order=None):
  79     """Creates a query object that will retrieve the appropriate exceptions.
  80
  81     Returns:
  82       A query to retrieve the exceptions required.
  83     """
  84     q = ereporter.ExceptionRecord.all()
  85     q.filter('date =', self.yesterday)
  86     q.filter('major_version =', self.major_version)
  87     if self.version_filter.lower() == 'latest':
  88       q.filter('minor_version =', self.minor_version)
  89     if order:
  90       q.order(order)
  91     return q
  92
  93   def GenerateReport(self, exceptions):
  94     """Generates an HTML exception report.
  95
  96     Args:
  97       exceptions: A list of ExceptionRecord objects. This argument will be
  98         modified by this function.
  99     Returns:
 100       An HTML exception report.
 101     """
 102     exceptions.sort(key=lambda e: (e.minor_version, -e.count))
 103     versions = [(minor, list(excs)) for minor, excs
 104                 in itertools.groupby(exceptions, lambda e: e.minor_version)]
 105
 106     template_values = {
 107         'version_filter': self.version_filter,
 108         'version_count': len(versions),
 109
 110         'exception_count': sum(len(excs) for _, excs in versions),
 111
 112         'occurrence_count': sum(y.count for x in versions for y in x[1]),
 113         'app_id': self.app_id,
 114         'major_version': self.major_version,
 115         'date': self.yesterday,
 116         'versions': versions,
 117     }
 118     path = os.path.join(os.path.dirname(__file__), 'templates', 'report.html')
 119     return template.render(path, template_values)
 120
 121   def SendReport(self, report):
 122     """Emails an exception report.
 123
 124     Args:
 125       report: A string containing the report to send.
 126     """
 127     subject = ('Daily exception report for app "%s", major version "%s"'
 128                % (self.app_id, self.major_version))
 129     report_text = saxutils.unescape(re.sub('<[^>]+>', '', report))
 130     mail_args = {
 131         'sender': self.sender,
 132         'subject': subject,
 133         'body': report_text,
 134         'html': report,
 135     }
 136     if self.to:
 137       mail_args['to'] = self.to
 138       self.send_mail(**mail_args)
 139     else:
 140       self.send_mail_to_admins(**mail_args)
 141
 142   def get(self):
 143     self.version_filter = self.request.GET.get('versions', 'all')
 144     self.sender = self.request.GET['sender']
 145     self.to = self.request.GET.get('to', None)
 146     report_date = self.request.GET.get('date', None)
 147     if report_date:
 148       self.yesterday = datetime.date(*[int(x) for x in report_date.split('-')])
 149     else:
 150       self.yesterday = datetime.date.today() - datetime.timedelta(days=1)
 151     self.app_id = os.environ['APPLICATION_ID']
 152     version = os.environ['CURRENT_VERSION_ID']
 153     self.major_version, self.minor_version = version.rsplit('.', 1)
 154     self.minor_version = int(self.minor_version)
 155     self.max_results = int(self.request.GET.get('max_results',
 156                                                 self.DEFAULT_MAX_RESULTS))
 157     self.debug = isTrue(self.request.GET.get('debug', 'false'))
 158     self.delete = isTrue(self.request.GET.get('delete', 'true'))
 159
 160     try:
 161       exceptions = self.GetQuery(order='-minor_version').fetch(self.max_results)
 162     except db.NeedIndexError:
 163       exceptions = self.GetQuery().fetch(self.max_results)
 164
 165     if exceptions:
 166       report = self.GenerateReport(exceptions)
 167       if self.debug:
 168         self.response.out.write(report)
 169       else:
 170         self.SendReport(report)
 171
 172       if self.delete:
 173         db.delete(exceptions)
 174
 175
 176 application = webapp.WSGIApplication([('.*', ReportGenerator)])
 177
 178
 179 def main():
 180   run_wsgi_app(application)
 181
 182
 183 if __name__ == '__main__':
 184   main()