Revision 7 as of 2012-12-07 14:52:32

Clear message


What does a developer do when a stack trace is not enough to completely debug an issue? They could find a user who is experiencing this problem and contact them, asking them to provide additional information. This is very time consuming and fraught with long delays.

A developer should be able to identify an issue that needs additional information, write a small amount of code to collect additional details on a system exhibiting the problem, and quickly get that run on such systems. This code should require no human interaction and should report back quickly, notifying the developer when there is something actionable.


Both and are signed with the Ubuntu certificate from Go Daddy. This certificate is included by default in the ssl-certs package.

  • Downloading seems safe.
  • Uploading
    • Mirror package uploading permissions to keep the same model we have today?
      • Query LP ACLs
      • Or we can keep it simple for now and restrict it to ~core-dev
  • Whoopsie needs to check the SSL certificate (strict server checking in libcurl)

Peer review

Would like some other core dev to at least review it. You get some pressure to fix this urgently and you rush something out.


  • How do we avoid password prompts?
    • One way would be a privileged apport dbus service that always services requests from the admin group.
    • Apport now uses pkexec rather than gksu.
  • We need to prevent hooks from running arbitrary code as root.
    • Not arbitrary code. We’re trusting the same group of developers as the archive (~core-dev).
      • attach_root_command maps to com.ubuntu.apport.package-hook
      • Martin will have a think about this.

Web interface

  • Need to sort out ~canonical not working with SSO in first (1073466)

  • Web UI restricted to ~core-dev.
  • Need UI for peer review system.


  • Per-problem hook (by SAS). How do we map all the SASes to the signature?
  • Package level hook
  • We're purposefully leaving out global, problem type-specific hooks for now as these should ideally live in the apport package.

Keeping existing hooks for ubuntu-bug

  • Fix bug whereby existing hooks are running on released versions (1084979)

  • Keep daisy hooks on the apport-gtk path, run existing hooks on ubuntu-bug path
  • SRU whoopsie and apport for server-side hook changes


  • quantity (if we received this 10 times, stop)
  • timeout (it is still running code, so after a week stop collecting)
  • Both quantity and timeout are editable fields with upper bounds
  • not-editable disk size upper bound (hooks can only include X MB)
  • Disable the hook once it hits the upper size bound. If the hook hits this while receiving data from the client, drop the connection and disable the hook.
  • We also need a disk upper bound on the client side, just in case. 50MB or so?

How do we get the reports with these fields?

  • They'll live in the HookResults CF. Needs to refer back to the original OOPS.

  • We need to be able to surface these on the problem page
  • Can be done as an API first for expediency
  • Daisy and the client pass a token back and forth and that token gets mapped to the correct bucket ID.
  • We need a way of seeing just package hook results. Deferred discussion until Matthew gets here.
  • Hook this into the alerts system as well. Notification when a report comes in with that information.

Delivery mechanism

Provide a list (BSON) of URLs to the individual hooks. It doesn’t need the package name or the bucket ID because it already has those locally.

We send to the client with a token that maps to the bucket. In the simple case this would be the Crash Signature that the SAS maps to. We still need a SAS to Crash Signature mapping so we can tell the right clients to get the specific hook for a crash signature.

Release specific hooks?

Restrict to a particular release upfront?

No, package hooks should check the DistroRelease field, when needed. Maybe DistroRelease checking should be in the web UI template for the hooks (if DistroRelease == ‘Ubuntu 13.04’:)


If there is time in the initial implementation, we should evaluate using compression for the increasingly large amount of data transfered between whoopsie and daisy. Candidates for this are snappy and zlib. xz could also be considered if we keep decompression time low on the server.

We should work with the webops team on this, as they may have strong opinions on the implementation. We will only get a few instances of this extra information out of the 100,000 reports we receive a day, given the limits we're putting on size, so this shouldn’t overload us.


Whoopsie gets a few hooks, downloads them, runs them with the python-apport code to update the report, sends the new keys in the report back (not any existing or modified), report gets written to the HookResults CF

Error handling

If a hook fails, the exception from the hook will be sent as a new field along with the other fields generated by the hook up until the point of failure. Daisy will write these into the new HookResults Column Family to indicate a failure of that hook.

Failed hooks will send an alert to the hook creator via SMS (mup) or email.


A new page will be added to that provides a report of hook usage.

This will include:

  • Active hooks with their expiry date. For each of the hooks, the number of reports received and the size of data transmitted so far will be included.
  • We will also record by day hook usage statistics (active, inactive, working, failed) to determine whether or not the hook mechanism is actually being used and working.

Test mechanism

Script to make testing a new hook against a local system or canonistack system easy

Launchpad bugs

A new checkbox is added in the server-side hooks UI for “Get someone to file this on Launchpad”. This is checked by apport via an api on daisy, where it asks if we want LP bugs for the SAS for which the report is about. If the answer is yes, then we create a LP bug with a specific tag that crash-digger is looking for and the SAS (attachment?). Crash-digger then finds this, looks up the SAS in and gets the crash signature back. It then writes the URL for that bucket into the bug and tells daisy to send off a notification that the server-side hook now has a LP bug. (and updates the BugToCrashSignatures CF)

This will let us mostly turn off retracing of Launchpad crashes.