Jump to: navigation, search

Development Resources/IP Log

The IP Log is a big part of the official release process. You are required to submit your project's IP Log prior to scheduling a release, or restructuring review. We encourage you to keep your IP log current rather than rushing at the end. The IP Log includes important information about your project that lets adopters know where all the code comes from, who owns the copyrights, and so forth. Specifically, the log tracks:

  • Licenses used;
  • Past and present committers;
  • Third-party libraries; and
  • Contributions from outside the project (i.e. non-committers)

The Eclipse IP Policy document describes (in fairly broad terms) the requirement for an IP Log. The Project IP Log page provides the definitive guide for what should be in your IP Log. The existing Automatic IP Log Tool and the new EMF-based one under development by the Woolsey Project can help you build your IP Log.


You need to record all the contributions that your project receives. All contributions should be accepted through Bugzilla. Ideally, contributions should be attached to the Bugzilla record that defines the bug that the contribution addresses. By attaching the patch to a Bugzilla record, the contributor implicitly agrees to the Eclipse terms of use (which, effectively, grants your project certain rights to use the contribution). Despite the implicit agreement, it's a good idea to get some kind of explicit endorsement from the contributor that it's okay to include the code in your project and distribute it under the license your project distributes code under (generally the EPL).

Some thoughts:

  • Only actual code contributions need to be included in the IP Log;
  • Only contributions from non-committers need to be included in the IP Log; and
  • Contributions that come from a developer before they become a committer do need to be included in the IP Log.

While your committers can attach patches to bugs, they generally don't need to (so long as they are observing the IP Due Diligence process).

The IP Log tools provide a lot of help with contributions. But you need to do some work to leverage this help. If you set the iplog flag on an attachment that contains a contribution (e..g a patch), that contribution will appear in an automatically-generated log (note that, iplog+ marked contributions from existing committers will be skipped). This is probably the most natural way to use the flag. To set this flag, open the "Details" for the attachment, set the value to “+”, and commit. That’s it. Do this for any attachment that contains something that you’ve committed into an Eclipse source code repository. This includes things like code patches, image files, XML schemas, and pretty much anything else. Only mark those attachments that actually make it into the project's code repository; just leave any other attachments alone. Unfortunately, there is no current support for setting the iplog flag from Mylyn, so you'll have to use a browser.

You can also set the iplog flag on an entire bug. You would do this if the bug’s summary or one of the comments contains code, or some other valuable asset that you commit into the source code repository. Unfortunately, flagging the bug indicates to the automated tools that every comment on the bug is a potential contribution (sadly, there is no way to set a flag on an individual comment). When you set the flag on the entire bug, you have to manually go through the generated log and remove any comments that shouldn’t be there. Yes, this can be painful. It’s made more painful by the fact that any new comments added to the bug after you’ve done your clean up will appear the next time the log is generated. This is particularly troublesome in the current Automatic IP Log Tool, and only slightly less so with the new one.

The bottom line is that it is always easier if your contributions come in the form of an attachment.

Only those attachments and bugs that contain contributions from developers who are not committers on the project at the time need be flagged. This is time-sensitive. If the contributor eventually does become a committer, those patches they’ve contributed while they were not a committer still need to be accounted for in the log and must therefore be flagged. The tools are smart enough to check the dates. Make sure that each committer’s Bugzilla email address matches the one in the Eclipse Foundation database, or you'll wind up with some extra stuff in your IP Log.