Bugzilla::Hook - Extendable extension hooks for Bugzilla code


 use Bugzilla::Hook;

 Bugzilla::Hook::process("hookname", { arg => $value, arg2 => $value2 });


Bugzilla allows extension modules to drop in and add routines at arbitrary points in Bugzilla code. These points are referred to as hooks. When a piece of standard Bugzilla code wants to allow an extension to perform additional functions, it uses Bugzilla::Hook's "process" subroutine to invoke any extension code if installed.

There is a sample extension in extensions/example/ that demonstrates most of the things described in this document, as well as many of the hooks available.

How Hooks Work

When a hook named HOOK_NAME is run, Bugzilla will attempt to invoke any source files named extensions/*/code/HOOK_NAME.pl.

So, for example, if your extension is called "testopia", and you want to have code run during the "install-update_db" hook, you would have a file called extensions/testopia/code/install-update_db.pl that contained perl code to run during that hook.

Arguments Passed to Hooks

Some hooks have params that are passed to them.

These params are accessible through "hook_args" in Bugzilla. That returns a hashref. Very frequently, if you want your hook to do anything, you have to modify these variables.

Versioning Extensions

Every extension must have a file in its root called info.pl. This file must return a hash when called with do. The hash must contain a 'version' key with the current version of the extension. Extension authors can also add any extra infomration to this hash if required, by adding a new key beginning with x_ which will not be used the core Bugzilla code.



Invoke any code hooks with a matching name from any installed extensions.

See customization.xml in the Bugzilla Guide for more information on Bugzilla's extension mechanism.

$name - The name of the hook to invoke.
$args - A hashref. The named args to pass to the hook. They will be accessible to the hook via "hook_args" in Bugzilla.
Returns (nothing)


This describes what hooks exist in Bugzilla currently. They are mostly in alphabetical order, but some related hooks are near each other instead of being alphabetical.


This happens at the end of "update" in Bugzilla::Bug, after all other changes are made to the database. This generally occurs inside a database transaction.


bug - The changed bug object, with all fields set to their updated values.
timestamp - The timestamp used for all updates in this transaction.
changes - The hash of changed fields. $changes->{field} = [old, new]


This happens in buglist.cgi after the standard columns have been defined and right before the display column determination. It gives you the opportunity to add additional display columns.


columns - A hashref, where the keys are unique string identifiers for the column being defined and the values are hashrefs with the following fields:
name - The name of the column in the database.
title - The title of the column as displayed to users.

The definition is structured as:

 $columns->{$id} = { name => $name, title => $title };


This happens in colchange.cgi right after the list of possible display columns have been defined and gives you the opportunity to add additional display columns to the list of selectable columns.


columns - An arrayref containing an array of column IDs. Any IDs added by this hook must have been defined in the the buglist-columns hook. See "buglist-columns".


This happens right before the template is loaded on enter_bug.cgi.


vars - A hashref. The variables that will be passed into the template.


This happens at the end of "process" in Bugzilla::Flag, after all other changes are made to the database and after emails are sent. It gives you a before/after snapshot of flags so you can react to specific flag changes. This generally occurs inside a database transaction.

Note that the interface to this hook is UNSTABLE and it may change in the future.


bug - The changed bug object.
timestamp - The timestamp used for all updates in this transaction.
old_flags - The snapshot of flag summaries from before the change.
new_flags - The snapshot of flag summaries after the change. Call my ($removed, $added) = diff_arrays(old_flags, new_flags) to get the list of changed flags, and search for a specific condition like added eq 'review-'.


Allows execution of custom code before the final checks are done in checksetup.pl.



A flag that indicates whether or not checksetup is running in silent mode.


Because of the way Bugzilla installation works, there can't be a normal hook during the time that checksetup.pl checks what modules are installed. (Bugzilla::Hook needs to have those modules installed--it's a chicken-and-egg problem.)

So instead of the way hooks normally work, this hook just looks for two subroutines (or constants, since all constants are just subroutines) in your file, called OPTIONAL_MODULES and REQUIRED_MODULES, which should return arrayrefs in the same format as OPTIONAL_MODULES and REQUIRED_MODULES in Bugzilla::Install::Requirements.

These subroutines will be passed an arrayref that contains the current Bugzilla requirements of the same type, in case you want to modify Bugzilla's requirements somehow. (Probably the most common would be to alter a version number or the "feature" element of OPTIONAL_MODULES.)

checksetup.pl will add these requirements to its own.

Please remember--if you put something in REQUIRED_MODULES, then checksetup.pl cannot complete unless the user has that module installed! So use OPTIONAL_MODULES whenever you can.


This happens at the very end of all the tables being updated during an installation or upgrade. If you need to modify your custom schema, do it here. No params are passed.


This allows you to add tables to Bugzilla. Note that we recommend that you prefix the names of your tables with some word, so that they don't conflict with any future Bugzilla tables.

If you wish to add new columns to existing Bugzilla tables, do that in "install-update_db".


schema - A hashref, in the format of "ABSTRACT_SCHEMA" in Bugzilla::DB::Schema. Add new hash keys to make new table definitions. checksetup.pl will automatically add these tables to the database when run.


Called before displaying the confirmation message when deleting a product.


vars - The template vars hashref.


This hook allows you to add your own modules to the WebService. (See Bugzilla::WebService.)



A hashref that you can specify the names of your modules and what Perl module handles the functions for that module. (This is actually sent to "dispatch_with" in SOAP::Lite. You can see how that's used in xmlrpc.cgi.)

The Perl module name must start with extensions::yourextension::lib:: (replace yourextension with the name of your extension). The package declaration inside that module must also start with extensions::yourextension::lib:: in that module's code.


  $dispatch->{Example} = "extensions::example::lib::Example";

And then you'd have a module extensions/example/lib/Example.pm

It's recommended that all the keys you put in dispatch start with the name of your extension, so that you don't conflict with the standard Bugzilla WebService functions (and so that you also don't conflict with other plugins).


If your webservice extension throws custom errors, you can set numeric codes for those errors here.

Extensions should use error codes above 10000, unless they are re-using an already-existing error code.



A hash that maps the names of errors (like invalid_param) to numbers. See "WS_ERROR_CODE" in Bugzilla::WebService::Constants for an example.