Add an optional per-day limit to the number of crash reports sent. The state

is maintained in an app-specified checkpoint file.  (#174, r=mmentovai)



git-svn-id: http://google-breakpad.googlecode.com/svn/trunk@171 4c0a9323-5329-0410-9bdc-e9ce6186880e

src/client/windows/sender/crash_report_sender.cc

@@ -33,17 +33,43 @@
 #include "client/windows/sender/crash_report_sender.h"
 #include "common/windows/http_upload.h"
 
+#if _MSC_VER < 1400  // MSVC 2005/8
+// Older MSVC doesn't have fscanf_s, but they are compatible as long as
+// we don't use the string conversions (%s/%c/%S/%C).
+#define fscanf_s fscanf
+#endif
+
 namespace google_breakpad {
 
-// static
+static const char kCheckpointSignature[] = "GBP1\n";
+
+CrashReportSender::CrashReportSender(const wstring &checkpoint_file)
+    : checkpoint_file_(checkpoint_file),
+      max_reports_per_day_(-1),
+      last_sent_date_(-1),
+      reports_sent_(0) {
+  FILE *fd;
+  if (OpenCheckpointFile(L"r", &fd) == 0) {
+    ReadCheckpoint(fd);
+    fclose(fd);
+  }
+}
+
 ReportResult CrashReportSender::SendCrashReport(
     const wstring &url, const map<wstring, wstring> &parameters,
     const wstring &dump_file_name, wstring *report_code) {
+  int today = GetCurrentDate();
+  if (today == last_sent_date_ &&
+      max_reports_per_day_ != -1 &&
+      reports_sent_ >= max_reports_per_day_) {
+    return RESULT_THROTTLED;
+  }
 
   int http_response = 0;
   bool result = HTTPUpload::SendRequest(
     url, parameters, dump_file_name, L"upload_file_minidump", report_code,
     &http_response);
+  ReportSent(today);
 
   if (result) {
     return RESULT_SUCCEEDED;
@@ -55,4 +81,58 @@ ReportResult CrashReportSender::SendCrashReport(
   }
 }
 
+void CrashReportSender::ReadCheckpoint(FILE *fd) {
+  char buf[128];
+  if (!fgets(buf, sizeof(buf), fd) ||
+      strcmp(buf, kCheckpointSignature) != 0) {
+    return;
+  }
+
+  if (fscanf_s(fd, "%d\n", &last_sent_date_) != 1) {
+    last_sent_date_ = -1;
+    return;
+  }
+  if (fscanf_s(fd, "%d\n", &reports_sent_) != 1) {
+    reports_sent_ = 0;
+    return;
+  }
+}
+
+void CrashReportSender::ReportSent(int today) {
+  // Update the report stats
+  if (today != last_sent_date_) {
+    last_sent_date_ = today;
+    reports_sent_ = 0;
+  }
+  ++reports_sent_;
+
+  // Update the checkpoint file
+  FILE *fd;
+  if (OpenCheckpointFile(L"w", &fd) == 0) {
+    fputs(kCheckpointSignature, fd);
+    fprintf(fd, "%d\n", last_sent_date_);
+    fprintf(fd, "%d\n", reports_sent_);
+    fclose(fd);
+  }
+}
+
+int CrashReportSender::GetCurrentDate() const {
+  SYSTEMTIME system_time;
+  GetSystemTime(&system_time);
+  return (system_time.wYear * 10000) + (system_time.wMonth * 100) +
+      system_time.wDay;
+}
+
+int CrashReportSender::OpenCheckpointFile(const wchar_t *mode, FILE **fd) {
+#if _MSC_VER >= 1400  // MSVC 2005/8
+  return _wfopen_s(fd, checkpoint_file_.c_str(), mode);
+#else
+  *fd = _wfopen(checkpoint_file_.c_str(), mode);
+  if (*fd == NULL) {
+    return errno;
+  }
+  return 0;
+#endif
+}
+
 }  // namespace google_breakpad

src/client/windows/sender/crash_report_sender.h

@@ -54,11 +54,29 @@ typedef enum {
   RESULT_FAILED = 0,  // Failed to communicate with the server; try later.
   RESULT_REJECTED,    // Successfully sent the crash report, but the
                       // server rejected it; don't resend this report.
-  RESULT_SUCCEEDED    // The server accepted the crash report.
+  RESULT_SUCCEEDED,   // The server accepted the crash report.
+  RESULT_THROTTLED    // No attempt was made to send the crash report, because
+                      // we exceeded the maximum reports per day.
 } ReportResult;
 
 class CrashReportSender {
  public:
+  // Initializes a CrashReportSender instance.
+  // If checkpoint_file is non-empty, breakpad will persist crash report
+  // state to this file.  A checkpoint file is required for
+  // set_max_reports_per_day() to function properly.
+  explicit CrashReportSender(const wstring &checkpoint_file);
+  ~CrashReportSender() {}
+
+  // Sets the maximum number of crash reports that will be sent in a 24-hour
+  // period.  This uses the state persisted to the checkpoint file.
+  // The default value of -1 means that there is no limit on reports sent.
+  void set_max_reports_per_day(int reports) {
+    max_reports_per_day_ = reports;
+  }
+
+  int max_reports_per_day() const { return max_reports_per_day_; }
+
   // Sends the specified minidump file, along with the map of
   // name value pairs, as a multipart POST request to the given URL.
   // Parameter names must contain only printable ASCII characters,
@@ -69,18 +87,35 @@ class CrashReportSender {
   // the return value is RESULT_SUCCEEDED), a code uniquely identifying the
   // report will be returned in report_code.
   // (Otherwise, report_code will be unchanged.)
-  static ReportResult SendCrashReport(const wstring &url,
+  ReportResult SendCrashReport(const wstring &url,
                                const map<wstring, wstring> &parameters,
                                const wstring &dump_file_name,
                                wstring *report_code);
 
  private:
-  // No instances of this class should be created.
+  // Reads persistent state from a checkpoint file.
-  // Disallow all constructors, destructors, and operator=.
+  void ReadCheckpoint(FILE *fd);
-  CrashReportSender();
+
+  // Called when a new report has been sent, to update the checkpoint state.
+  void ReportSent(int today);
+
+  // Returns today's date (UTC) formatted as YYYYMMDD.
+  int GetCurrentDate() const;
+
+  // Opens the checkpoint file with the specified mode.
+  // Returns zero on success, or an error code on failure.
+  int OpenCheckpointFile(const wchar_t *mode, FILE **fd);
+
+  wstring checkpoint_file_;
+  int max_reports_per_day_;
+  // The last date on which we sent a report, expressed as YYYYMMDD.
+  int last_sent_date_;
+  // Number of reports sent on last_sent_date_
+  int reports_sent_;
+
+  // Disallow copy constructor and operator=
   explicit CrashReportSender(const CrashReportSender &);
   void operator=(const CrashReportSender &);
-  ~CrashReportSender();
 };
 
 }  // namespace google_breakpad