This document describes an older version of Celery (2.1). For the latest stable version please go here.

Change history


  • In 2.2 remote control commands are not persistent anymore. There is now a new setting you can use to disable persistence in 2.1 as well: the CELERY_BROADCAST_PERSISTENT setting.

    This setting will not have any effect in 2.2.


release-date:2010-12-03 12:00 PM CEST
  • Celery programs now hijacks the root logger by default (Issue #250).

    In 2.1 logging behavior was changed to not configure logging if it was already configured. The problem is that some libraries does not play nice and hijack the root logger, or use logging.basicConfig – resulting in users not getting any output or logs.

    So instead we now always hijack the root logger, but if you want the previous behavior you can disable the CELERYD_HIJACK_ROOT_LOGGER setting:



  • Execution options to apply_async now takes precedence over options returned by active routers. This was a regression introduced recently (Issue #244).
  • celeryev curses monitor: Long arguments are now truncated so curses doesn’t crash with out of bounds errors. (Issue #235).
  • celeryd: Channel errors occurring while handling control commands no longer crash the worker but are instead logged with severity error.
  • SQLAlchemy database backend: Fixed a race condition occurring when the client wrote the pending state. Just like the Django database backend, it does no longer save the pending state (Issue #261 + Issue #262).
  • task.apply: propagate=True now raises exceptions from the original frame, keeping the same stacktrace (Issue #256).
  • Error email body now uses repr(exception) instead of str(exception), as the latter could result in Unicode decode errors (Issue #245).
  • Error e-mail timeout value is now configurable by using the EMAIL_TIMEOUT setting.
  • celeryev: Now works on Windows (but the curses monitor won’t work without having curses).
  • Unit test output no longer emits non-standard characters.
  • celeryd: The broadcast consumer is now closed if the connection is reset.
  • celeryd: Now properly handles errors occurring while trying to acknowledge the message.
  • Happy holidays :)


  • Adding Contributing.
  • Added Optimizing.
  • Added Security section to the FAQ.
  • Periodic Task User Guide: Fixed typo in crontab example table (Issue #239).


release-date:2010-11-09 17:00 PM CEST
  • Fixed deadlocks in timer2 which could lead to djcelerymon/celeryev -c hanging.

  • EventReceiver: now sends heartbeat request to find workers.

    This means celeryev and friends finds workers immediately at startup.

  • celeryev cursesmon: Set screen_delay to 10ms, so the screen refreshes more often.

  • Fixed pickling errors when pickling AsyncResult on older Python versions.

  • celeryd: prefetch count was decremented by eta tasks even if there were no active prefetch limits.


release-date:2010-10-29 15:00 PM CEST


  • AMQP result backend: Delete result queue after having successfully polled the result.

  • task.queue attribute and queue argument to apply_async was not working.

  • Fixed bug with task log messages being output twice when logging to stderr.

    • Default logfile is now sys.__stderr__ instead of sys.stderr, so the messages are not being redirected back to the stderr logger.
    • In addition task loggers now disable propagate by default. You can re-enable this by using the propagate argument to task.get_logger.
  • A 2 second timeout for sending error e-mails has been added.

    The mail server used should have as little latency as possible, as the sending of error e-mails is currently blocking the worker. Preferably the mailserver should be local.

  • celeryd: Now sends the task-retried event for retried tasks.

    This means retried tasks will show as RETRY in the event monitors.

  • Logging should now handle utf-8 correctly.

  • celeryd: Added exc_info error logging messages.

    This is used by tools like django-sentry to provide more context.

  • The time_start for a task is now set when the task is acknowledged, not when it is sent to the pool.

    See Issue #233.

  • Fixed Sunday issue with the crontab scheduler.

  • Fixed a race condition where Timer.enter is called twice before the thread actually runs.

  • The mail_admins method is now in the loader, so it can be overriden. (django-celery now uses the Django mail admins mechanism)).

  • celeryd: Added –scheduler option to be used in combination with -B.

    See Issue #229.

  • Tasks Userguide: Added section about decorating tasks (Issue #224).

  • Now links to celery-pylons on PyPI instead of on Bitbucket.

  • celeryd: Now honors ignore result for WorkerLostError and timeout errors.

  • celerybeat: Fixed UnboundLocalError in celerybeat logging when using logging setup signals.

  • celeryd: All log messages now includes exc_info.

  • ETA scheduler now uses a not_empty condition to wait for new tasks instead of a sleep polling loop

  • celeryd now shows the total runtime for a task in the task succeeded log message.


release-date:2010-10-14 14:00 PM CEST


  • Now working on Windows again.

    Removed dependency on the pwd/grp modules.

  • snapshots: Fixed race condition leading to loss of events.

  • celeryd: Reject tasks with an eta that cannot be converted to a time stamp.

    See issue #209

  • concurrency.processes.pool: The semaphore was released twice for each task (both at ACK and result ready).

    This has been fixed, and it is now released only once per task.


    See issue #214

  • control command dump_scheduled: was using old .info attribute

  • celeryd-multi: Fixed set changed size during iteration bug

    occurring in the restart command.

  • celeryd: Accidentally tried to use additional command line arguments.

    This would lead to an error like:

    got multiple values for keyword argument 'concurrency'.

    Additional command line arguments are now ignored, and does not produce this error. However – we do reserve the right to use positional arguments in the future, so please do not depend on this behavior.

  • celerybeat: Now respects routers and task execution options again.

  • celerybeat: Now reuses the publisher instead of the connection.

  • Cache result backend: Using float as the expires argument to cache.set is deprecated by the memcached libraries, so we now automatically cast to int.

  • unit tests: No longer emits logging and warnings in test output.


  • Now depends on carrot version 0.10.7.


    CELERY_REDIRECT_STDOUTS is used by celeryd and celerybeat. All output to stdout and stderr will be redirected to the current logger if enabled.

    CELERY_REDIRECT_STDOUTS_LEVEL decides the log level used and is WARNING by default.


    This setting is used to define the default for the -S option to celerybeat.


    CELERYBEAT_SCHEDULER = "djcelery.schedulers.DatabaseScheduler"
  • Added Task.expires: Used to set default expiry time for tasks.

  • New remote control commands: add_consumer and cancel_consumer.

    add_consumer(queue, exchange, exchange_type, routing_key,

    Tells the worker to declare and consume from the specified declaration.


    Tells the worker to stop consuming from queue (by queue name).

    Commands also added to celeryctl and inspect.

    Example using celeryctl to start consuming from queue “queue”, in exchange “exchange”, of type “direct” using binding key “key”:

    $ celeryctl inspect add_consumer queue exchange direct key
    $ celeryctl inspect cancel_consumer queue

    See celeryctl: Management Utility for more information about the celeryctl program.

    Another example using inspect:

    >>> from celery.task.control import inspect
    >>> inspect.add_consumer(queue="queue", exchange="exchange",
    ...                      exchange_type="direct",
    ...                      routing_key="key",
    ...                      durable=False,
    ...                      auto_delete=True)
    >>> inspect.cancel_consumer("queue")
  • celerybeat: Now logs the traceback if a message can’t be sent.

  • celerybeat: Now enables a default socket timeout of 30 seconds.

  • README/introduction/homepage: Added link to Flask-Celery.


release-date:2010-10-08 12:00 PM CEST

Important Notes

  • Celery is now following the versioning semantics defined by semver.

    This means we are no longer allowed to use odd/even versioning semantics By our previous versioning scheme this stable release should have been version 2.2.

  • Now depends on Carrot 0.10.7.

  • No longer depends on SQLAlchemy, this needs to be installed separately if the database result backend is used.

  • django-celery now comes with a monitor for the Django Admin interface. This can also be used if you’re not a Django user. See Django Admin Monitor and Using outside of Django for more information.

  • If you get an error after upgrading saying: AttributeError: 'module' object has no attribute 'system',

    Then this is because the celery.platform module has been renamed to celery.platforms to not collide with the built-in platform module.

    You have to remove the old (and maybe platform.pyc) file from your previous Celery installation.

    To do this use python to find the location of this module:

    $ python
    >>> import celery.platform
    >>> celery.platform
    <module 'celery.platform' from '/opt/devel/celery/celery/platform.pyc'>

    Here the compiled module is in /opt/devel/celery/celery/, to remove the offending files do:

    $ rm -f /opt/devel/celery/celery/*


  • Added support for expiration of AMQP results (requires RabbitMQ 2.1.0)

    The new configuration option CELERY_AMQP_TASK_RESULT_EXPIRES sets the expiry time in seconds (can be int or float):

    CELERY_AMQP_TASK_RESULT_EXPIRES = 30 * 60  # 30 minutes.
    CELERY_AMQP_TASK_RESULT_EXPIRES = 0.80     # 800 ms.
  • celeryev: Event Snapshots

    If enabled, celeryd sends messages about what the worker is doing. These messages are called “events”. The events are used by real-time monitors to show what the cluster is doing, but they are not very useful for monitoring over a longer period of time. Snapshots lets you take “pictures” of the clusters state at regular intervals. This can then be stored in a database to generate statistics with, or even monitoring over longer time periods.

    django-celery now comes with a Celery monitor for the Django Admin interface. To use this you need to run the django-celery snapshot camera, which stores snapshots to the database at configurable intervals. See Using outside of Django for information about using this monitor if you’re not using Django.

    To use the Django admin monitor you need to do the following:

    1. Create the new database tables.

      $ python syncdb

    2. Start the django-celery snapshot camera:

      $ python celerycam
    3. Open up the django admin to monitor your cluster.

    The admin interface shows tasks, worker nodes, and even lets you perform some actions, like revoking and rate limiting tasks, and shutting down worker nodes.

    There’s also a Debian init.d script for celeryev available, see Running celeryd as a daemon for more information.

    New command line arguments to celeryev:

    • -c|--camera: Snapshot camera class to use.
    • --logfile|-f: Log file
    • --loglevel|-l: Log level
    • --maxrate|-r: Shutter rate limit.
    • --freq|-F: Shutter frequency

    The --camera argument is the name of a class used to take snapshots with. It must support the interface defined by

    Shutter frequency controls how often the camera thread wakes up, while the rate limit controls how often it will actually take a snapshot. The rate limit can be an integer (snapshots/s), or a rate limit string which has the same syntax as the task rate limit strings ("200/m", "10/s", "1/h", etc).

    For the Django camera case, this rate limit can be used to control how often the snapshots are written to the database, and the frequency used to control how often the thread wakes up to check if there’s anything new.

    The rate limit is off by default, which means it will take a snapshot for every --frequency seconds.

  • broadcast(): Added callback argument, this can be used to process replies immediately as they arrive.

  • celeryctl: New command-line utility to manage and inspect worker nodes, apply tasks and inspect the results of tasks.

    See also

    The celeryctl: Management Utility section in the User Guide.

    Some examples:

    $ celeryctl apply tasks.add -a '[2, 2]' --countdown=10
    $ celeryctl inspect active
    $ celeryctl inspect registered_tasks
    $ celeryctl inspect scheduled
    $ celeryctl inspect --help
    $ celeryctl apply --help
  • Added the ability to set an expiry date and time for tasks.


    >>> # Task expires after one minute from now.
    >>> task.apply_async(args, kwargs, expires=60)
    >>> # Also supports datetime
    >>> task.apply_async(args, kwargs,
    ...         + timedelta(days=1)

    When a worker receives a task that has been expired it will be marked as revoked (celery.exceptions.TaskRevokedError).

  • Changed the way logging is configured.

    We now configure the root logger instead of only configuring our custom logger. In addition we don’t hijack the multiprocessing logger anymore, but instead use a custom logger name for different applications:

    Application Logger Name
    celeryd “celery”
    celerybeat “celery.beat”
    celeryev “celery.ev”

    This means that the loglevel and logfile arguments will affect all registered loggers (even those from 3rd party libraries). Unless you configure the loggers manually as shown below, that is.

    Users can choose to configure logging by subscribing to the :data:`~celery.signals.setup_logging` signal:

    from logging.config import fileConfig
    from celery import signals
    def setup_logging(**kwargs):

    If there are no receivers for this signal, the logging subsystem will be configured using the --loglevel/--logfile argument, this will be used for all defined loggers.

    Remember that celeryd also redirects stdout and stderr to the celery logger, if manually configure logging you also need to redirect the stdouts manually:

     from logging.config import fileConfig
     from celery import log
    def setup_logging(**kwargs):
         import logging
         stdouts = logging.getLogger("mystdoutslogger")
         log.redirect_stdouts_to_logger(stdouts, loglevel=logging.WARNING)
  • celeryd: Added command-line option -I/--include:

    A comma separated list of (task) modules to be imported.


    $ celeryd -I app1.tasks,app2.tasks
  • celeryd: now emits a warning if running as the root user (euid is 0).

  • celery.messaging.establish_connection(): Ability to override defaults used using keyword argument “defaults”.

  • celeryd: Now uses multiprocessing.freeze_support() so that it should work with py2exe, PyInstaller, cx_Freeze, etc.

  • celeryd: Now includes more metadata for the STARTED state: PID and host name of the worker that started the task.

    See issue #181

  • subtask: Merge additional keyword arguments to subtask() into task keyword arguments.


    >>> s = subtask((1, 2), {"foo": "bar"}, baz=1)
    >>> s.args
    (1, 2)
    >>> s.kwargs
    {"foo": "bar", "baz": 1}

    See issue #182.

  • celeryd: Now emits a warning if there is already a worker node using the same name running on the same virtual host.

  • AMQP result backend: Sending of results are now retried if the connection is down.

  • AMQP result backend: result.get(): Wait for next state if state is not


  • TaskSetResult now supports subscription.

    >>> res = TaskSet(tasks).apply_async()
    >>> res[0].get()
  • Added Task.send_error_emails + Task.error_whitelist, so these can be configured per task instead of just by the global setting.

  • Added Task.store_errors_even_if_ignored, so it can be changed per Task, not just by the global setting.

  • The crontab scheduler no longer wakes up every second, but implements remaining_estimate (Optimization).

  • celeryd: Store FAILURE result if the

    WorkerLostError exception occurs (worker process disappeared).

  • celeryd: Store FAILURE result if one of the *TimeLimitExceeded exceptions occurs.

  • Refactored the periodic task responsible for cleaning up results.

    • The backend cleanup task is now only added to the schedule if


    • If the schedule already contains a periodic task named “celery.backend_cleanup” it won’t change it, so the behavior of the backend cleanup task can be easily changed.

    • The task is now run every day at 4:00 AM, rather than every day since the first time it was run (using crontab schedule instead of run_every)

    • Renamed celery.task.builtins.DeleteExpiredTaskMetaTask

      -> celery.task.builtins.backend_cleanup

    • The task itself has been renamed from “celery.delete_expired_task_meta” to “celery.backend_cleanup”

    See issue #134.

  • Implemented AsyncResult.forget for sqla/cache/redis/tyrant backends. (Forget and remove task result).

    See issue #184.

  • TaskSetResult.join: Added ‘propagate=True’ argument.

    When set to False exceptions occurring in subtasks will not be re-raised.

  • Added Task.update_state(task_id, state, meta) as a shortcut to task.backend.store_result(task_id, meta, state).

    The backend interface is “private” and the terminology outdated, so better to move this to Task so it can be used.

  • timer2: Set self.running=False in stop() so it won’t try to join again on subsequent calls to stop().

  • Log colors are now disabled by default on Windows.

  • celery.platform renamed to celery.platforms, so it doesn’t collide with the built-in platform module.

  • Exceptions occurring in Mediator+Pool callbacks are now caught and logged instead of taking down the worker.

  • Redis result backend: Now supports result expiration using the Redis EXPIRE command.

  • unit tests: Don’t leave threads running at tear down.

  • celeryd: Task results shown in logs are now truncated to 46 chars.

  • Task.__name__ is now an alias to self.__class__.__name__.

    This way tasks introspects more like regular functions.

  • Task.retry: Now raises TypeError if kwargs argument is empty.

    See issue #164.

  • timedelta_seconds: Use timedelta.total_seconds if running on Python 2.7

  • TokenBucket: Generic Token Bucket algorithm

  • Recording of cluster state can now be paused and resumed, including support for buffering.


    Pauses recording of the stream.

    If buffer is true, events received while being frozen will be buffered, and may be replayed later.


    Resumes recording of the stream.

    If replay is true, then the recorded buffer will be applied.


    With a function to apply, freezes the stream before, and replays the buffer after the function returns.

  • EventReceiver.capture Now supports a timeout keyword argument.

  • celeryd: The mediator thread is now disabled if CELERY_RATE_LIMITS is enabled, and tasks are directly sent to the pool without going through the ready queue (Optimization).


  • Pool: Process timed out by TimeoutHandler must be joined by the Supervisor, so don’t remove it from the internal process list.

    See issue #192.

  • TaskPublisher.delay_task now supports exchange argument, so exchange can be overridden when sending tasks in bulk using the same publisher

    See issue #187.

  • celeryd no longer marks tasks as revoked if CELERY_IGNORE_RESULT is enabled.

    See issue #207.

  • AMQP Result backend: Fixed bug with result.get() if CELERY_TRACK_STARTED enabled.

    result.get() would stop consuming after receiving the STARTED state.

  • Fixed bug where new processes created by the pool supervisor becomes stuck while reading from the task Queue.

  • Fixed timing issue when declaring the remote control command reply queue

    This issue could result in replies being lost, but have now been fixed.

  • Backward compatible LoggerAdapter implementation: Now works for Python 2.4.

    Also added support for several new methods: fatal, makeRecord, _log, log, isEnabledFor, addHandler, removeHandler.


  • celeryd-multi: Added daemonization support.

    celeryd-multi can now be used to start, stop and restart worker nodes.

    $ celeryd-multi start jerry elaine george kramer

    This also creates PID files and log files (, ..., celeryd@jerry.log. To specify a location for these files use the --pidfile and --logfile arguments with the %n format:

    $ celeryd-multi start jerry elaine george kramer \
                    --logfile=/var/log/celeryd@%n.log \


    $ celeryd-multi stop jerry elaine george kramer

    Restarting. The nodes will be restarted one by one as the old ones are shutdown:

    $ celeryd-multi restart jerry elaine george kramer

    Killing the nodes (WARNING: Will discard currently executing tasks):

    $ celeryd-multi kill jerry elaine george kramer

    See celeryd-multi help for help.

  • celeryd-multi: start command renamed to show.

    celeryd-multi start will now actually start and detach worker nodes. To just generate the commands you have to use celeryd-multi show.

  • celeryd: Added --pidfile argument.

    The worker will write its pid when it starts. The worker will not be started if this file exists and the pid contained is still alive.

  • Added generic init.d script using celeryd-multi


  • Added User guide section: Monitoring

  • Added user guide section: Periodic Tasks

    Moved from getting-started/periodic-tasks and updated.

  • tutorials/external moved to new section: “community”.

  • References has been added to all sections in the documentation.

    This makes it easier to link between documents.


release-date:2010-08-27 12:00 P.M CEST


  • celeryd: Properly handle connection errors happening while closing consumers.

  • celeryd: Events are now buffered if the connection is down, then sent when the connection is re-established.

  • No longer depends on the mailer package.

    This package had a name space collision with django-mailer, so its functionality was replaced.

  • Redis result backend: Documentation typos: Redis doesn’t have database names, but database numbers. The default database is now 0.

  • inspect: registered_tasks was requesting an invalid command because of a typo.

    See issue #170.

  • CELERY_ROUTES: Values defined in the route should now have precedence over values defined in CELERY_QUEUES when merging the two.

    With the follow settings:

    CELERY_QUEUES = {"cpubound": {"exchange": "cpubound",
                                  "routing_key": "cpubound"}}
    CELERY_ROUTES = {"tasks.add": {"queue": "cpubound",
                                   "routing_key": "tasks.add",
                                   "serializer": "json"}}

    The final routing options for tasks.add will become:

    {"exchange": "cpubound",
     "routing_key": "tasks.add",
     "serializer": "json"}

    This was not the case before: the values in CELERY_QUEUES would take precedence.

  • Worker crashed if the value of CELERY_TASK_ERROR_WHITELIST was not an iterable

  • apply(): Make sure kwargs["task_id"] is always set.

  • AsyncResult.traceback: Now returns None, instead of raising KeyError if traceback is missing.

  • inspect: Replies did not work correctly if no destination was specified.

  • Can now store result/metadata for custom states.

  • celeryd: A warning is now emitted if the sending of task error e-mails fails.

  • celeryev: Curses monitor no longer crashes if the terminal window is resized.

    See issue #160.

  • celeryd: On OS X it is not possible to run os.exec* in a process that is threaded.

    This breaks the SIGHUP restart handler, and is now disabled on OS X, emitting a warning instead.

    See issue #152.

  • celery.execute.trace: Properly handle raise(str), which is still allowed in Python 2.4.

    See issue #175.

  • Using urllib2 in a periodic task on OS X crashed because of the proxy auto detection used in OS X.

    This is now fixed by using a workaround. See issue #143.

  • Debian init scripts: Commands should not run in a sub shell

    See issue #163.

  • Debian init scripts: Use the absolute path of celeryd to allow stat

    See issue #162.


  • getting-started/broker-installation: Fixed typo

    set_permissions "" -> set_permissions ".*".

  • Tasks User Guide: Added section on database transactions.

    See issue #169.

  • Routing User Guide: Fixed typo “feed”: -> {“queue”: “feeds”}.

    See issue #169.

  • Documented the default values for the CELERYD_CONCURRENCY and CELERYD_PREFETCH_MULTIPLIER settings.

  • Tasks User Guide: Fixed typos in the subtask example

  • celery.signals: Documented worker_process_init.

  • Daemonization cookbook: Need to export DJANGO_SETTINGS_MODULE in /etc/default/celeryd.

  • Added some more FAQs from stack overflow

  • Daemonization cookbook: Fixed typo CELERYD_LOGFILE/CELERYD_PIDFILE


    Also added troubleshooting section for the init scripts.


release-date:2010-07-22 11:31 A.M CEST
  • Routes: When using the dict route syntax, the exchange for a task could disappear making the task unroutable.

    See issue #158.

  • Test suite now passing on Python 2.4

  • No longer have to type PYTHONPATH=. to use celeryconfig in the current directory.

    This is accomplished by the default loader ensuring that the current directory is in sys.path when loading the config module. sys.path is reset to its original state after loading.

    Adding the current working directory to sys.path without the user knowing may be a security issue, as this means someone can drop a Python module in the users directory that executes arbitrary commands. This was the original reason not to do this, but if done only when loading the config module, this means that the behavior will only apply to the modules imported in the config module, which I think is a good compromise (certainly better than just explicitly setting PYTHONPATH=. anyway)

  • Experimental Cassandra backend added.

  • celeryd: SIGHUP handler accidentally propagated to worker pool processes.

    In combination with 7a7c44e39344789f11b5346e9cc8340f5fe4846c this would make each child process start a new celeryd when the terminal window was closed :/

  • celeryd: Do not install SIGHUP handler if running from a terminal.

    This fixes the problem where celeryd is launched in the background when closing the terminal.

  • celeryd: Now joins threads at shutdown.

    See issue #152.

  • Test tear down: Don’t use atexit but nose’s teardown() functionality instead.

    See issue #154.

  • Debian init script for celeryd: Stop now works correctly.

  • Task logger: warn method added (synonym for warning)

  • Can now define a white list of errors to send error e-mails for.


    CELERY_TASK_ERROR_WHITELIST = ('myapp.MalformedInputError')

    See issue #153.

  • celeryd: Now handles overflow exceptions in time.mktime while parsing the ETA field.

  • LoggerWrapper: Try to detect loggers logging back to stderr/stdout making an infinite loop.

  • Added celery.task.control.inspect: Inspects a running worker.


    # Inspect a single worker
    >>> i = inspect("")
    # Inspect several workers
    >>> i = inspect(["", ""])
    # Inspect all workers consuming on this vhost.
    >>> i = inspect()
    ### Methods
    # Get currently executing tasks
    # Get currently reserved tasks
    >>> i.reserved()
    # Get the current eta schedule
    >>> i.scheduled()
    # Worker statistics and info
    >>> i.stats()
    # List of currently revoked tasks
    >>> i.revoked()
    # List of registered tasks
    >>> i.registered_tasks()
  • Remote control commands dump_active/dump_reserved/dump_schedule now replies with detailed task requests.

    Containing the original arguments and fields of the task requested.

    In addition the remote control command set_loglevel has been added, this only changes the log level for the main process.

  • Worker control command execution now catches errors and returns their string representation in the reply.

  • Functional test suite added contains utilities to start and stop an embedded celeryd process, for use in functional testing.


release-date:2010-07-09 03:02 P.M CEST
  • multiprocessing.pool: Now handles encoding errors, so that pickling errors doesn’t crash the worker processes.

  • The remote control command replies was not working with RabbitMQ 1.8.0’s stricter equivalence checks.

    If you’ve already hit this problem you may have to delete the declaration:

    $ camqadm exchange.delete celerycrq


    $ python camqadm exchange.delete celerycrq
  • A bug sneaked in the ETA scheduler that made it only able to execute one task per second(!)

    The scheduler sleeps between iterations so it doesn’t consume too much CPU. It keeps a list of the scheduled items sorted by time, at each iteration it sleeps for the remaining time of the item with the nearest deadline. If there are no eta tasks it will sleep for a minimum amount of time, one second by default.

    A bug sneaked in here, making it sleep for one second for every task that was scheduled. This has been fixed, so now it should move tasks like hot knife through butter.

    In addition a new setting has been added to control the minimum sleep interval; CELERYD_ETA_SCHEDULER_PRECISION. A good value for this would be a float between 0 and 1, depending on the needed precision. A value of 0.8 means that when the ETA of a task is met, it will take at most 0.8 seconds for the task to be moved to the ready queue.

  • Pool: Supervisor did not release the semaphore.

    This would lead to a deadlock if all workers terminated prematurely.

  • Added Python version trove classifiers: 2.4, 2.5, 2.6 and 2.7

  • Tests now passing on Python 2.7.

  • Task.__reduce__: Tasks created using the task decorator can now be pickled.

  • nose added to tests_require.

  • Pickle should now work with SQLAlchemy 0.5.x

  • New homepage design by Jan Henrik Helmers:

  • New Sphinx theme by Armin Ronacher:

  • Fixed “pending_xref” errors shown in the HTML rendering of the documentation. Apparently this was caused by new changes in Sphinx 1.0b2.

  • Router classes in CELERY_ROUTES are now imported lazily.

    Importing a router class in a module that also loads the Celery environment would cause a circular dependency. This is solved by importing it when needed after the environment is set up.

  • CELERY_ROUTES was broken if set to a single dict.

    This example in the docs should now work again:

    CELERY_ROUTES = {"feed.tasks.import_feed": "feeds"}
  • CREATE_MISSING_QUEUES was not honored by apply_async.

  • New remote control command: stats

    Dumps information about the worker, like pool process ids, and total number of tasks executed by type.

    Example reply:

         'total': {'tasks.sleeptask': 6},
         'pool': {'timeouts': [None, None],
                  'processes': [60376, 60377],
                  'max-concurrency': 2,
                  'max-tasks-per-child': None,
                  'put-guarded-by-semaphore': True}}]
  • New remote control command: dump_active

    Gives a list of tasks currently being executed by the worker. By default arguments are passed through repr in case there are arguments that is not JSON encodable. If you know the arguments are JSON safe, you can pass the argument safe=True.

    Example reply:

    >>> broadcast("dump_active", arguments={"safe": False}, reply=True)
    [{'worker.local': [
        {'args': '(1,)',
         'time_start': 1278580542.6300001,
         'name': 'tasks.sleeptask',
         'delivery_info': {
             'consumer_tag': '30',
             'routing_key': 'celery',
             'exchange': 'celery'},
         'hostname': 'casper.local',
         'acknowledged': True,
         'kwargs': '{}',
         'id': '802e93e9-e470-47ed-b913-06de8510aca2',
  • Added experimental support for persistent revokes.

    Use the -S|--statedb argument to celeryd to enable it:

    $ celeryd --statedb=/var/run/celeryd

    This will use the file: /var/run/celeryd.db, as the shelve module automatically adds the .db suffix.


release-date:2010-07-02 02:30 P.M CEST


Celery 2.0 contains backward incompatible changes, the most important being that the Django dependency has been removed so Celery no longer supports Django out of the box, but instead as an add-on package called django-celery.

We’re very sorry for breaking backwards compatibility, but there’s also many new and exciting features to make up for the time you lose upgrading, so be sure to read the News section.

Quite a lot of potential users have been upset about the Django dependency, so maybe this is a chance to get wider adoption by the Python community as well.

Big thanks to all contributors, testers and users!

Upgrading for Django-users

Django integration has been moved to a separate package: django-celery.

  • To upgrade you need to install the django-celery module and change:

    INSTALLED_APPS = "celery"


    INSTALLED_APPS = "djcelery"
  • If you use mod_wsgi you need to add the following line to your .wsgi file:

    import os
    os.environ["CELERY_LOADER"] = "django"
  • The following modules has been moved to django-celery:

    Module name Replace with
    celery.models djcelery.models
    celery.managers djcelery.managers
    celery.views djcelery.views
    celery.urls djcelery.urls
    celery.loaders.djangoapp djcelery.loaders
    celery.backends.database djcelery.backends.database
    celery.backends.cache djcelery.backends.cache

Importing djcelery will automatically setup Celery to use Django loader. loader. It does this by setting the CELERY_LOADER environment variable to "django" (it won’t change it if a loader is already set.)

When the Django loader is used, the “database” and “cache” result backend aliases will point to the djcelery backends instead of the built-in backends, and configuration will be read from the Django settings.

Upgrading for others

Database result backend

The database result backend is now using SQLAlchemy instead of the Django ORM, see Supported Databases for a table of supported databases.

The DATABASE_* settings has been replaced by a single setting: CELERY_RESULT_DBURI. The value here should be an SQLAlchemy Connection String, some examples include:

# sqlite (filename)
CELERY_RESULT_DBURI = "sqlite:///celerydb.sqlite"

# mysql
CELERY_RESULT_DBURI = "mysql://scott:tiger@localhost/foo"

# postgresql
CELERY_RESULT_DBURI = "postgresql://scott:tiger@localhost/mydatabase"

# oracle
CELERY_RESULT_DBURI = "oracle://scott:tiger@"

See SQLAlchemy Connection Strings for more information about connection strings.

To specify additional SQLAlchemy database engine options you can use the CELERY_RESULT_ENGINE_OPTIONS setting:

# echo enables verbose logging from SQLAlchemy.

Cache result backend

The cache result backend is no longer using the Django cache framework, but it supports mostly the same configuration syntax:

CELERY_CACHE_BACKEND = "memcached://;"

To use the cache backend you must either have the pylibmc or python-memcached library installed, of which the former is regarded as the best choice.

The support backend types are memcached:// and memory://, we haven’t felt the need to support any of the other backends provided by Django.

Backward incompatible changes

  • Default (python) loader now prints warning on missing instead of raising ImportError.

    celeryd raises ImproperlyConfigured if the configuration is not set up. This makes it possible to use –help etc., without having a working configuration.

    Also this makes it possible to use the client side of celery without being configured:

    >>> from carrot.connection import BrokerConnection
    >>> conn = BrokerConnection("localhost", "guest", "guest", "/")
    >>> from celery.execute import send_task
    >>> r = send_task("", args=(), kwargs={}, connection=conn)
    >>> from celery.backends.amqp import AMQPBackend
    >>> r.backend = AMQPBackend(connection=conn)
    >>> r.get()
  • The following deprecated settings has been removed (as scheduled by the deprecation timeline):

    Setting name Replace with
  • The module has been removed, use celery.task.http instead (as scheduled by the deprecation timeline).

  • It’s no longer allowed to skip the class name in loader names. (as scheduled by the deprecation timeline):

    Assuming the implicit Loader class name is no longer supported, if you use e.g.:

    CELERY_LOADER = "myapp.loaders"

    You need to include the loader class name, like this:

    CELERY_LOADER = "myapp.loaders.Loader"
  • CELERY_TASK_RESULT_EXPIRES now defaults to 1 day.

    Previous default setting was to expire in 5 days.

  • AMQP backend: Don’t use different values for auto_delete.

    This bug became visible with RabbitMQ 1.8.0, which no longer allows conflicting declarations for the auto_delete and durable settings.

    If you’ve already used celery with this backend chances are you have to delete the previous declaration:

    $ camqadm exchange.delete celeryresults
  • Now uses pickle instead of cPickle on Python versions <= 2.5

    cPickle is broken in Python <= 2.5.

    It unsafely and incorrectly uses relative instead of absolute imports, so e.g.:




    Your best choice is to upgrade to Python 2.6, as while the pure pickle version has worse performance, it is the only safe option for older Python versions.


  • celeryev: Curses Celery Monitor and Event Viewer.

    This is a simple monitor allowing you to see what tasks are executing in real-time and investigate tracebacks and results of ready tasks. It also enables you to set new rate limits and revoke tasks.



    If you run celeryev with the -d switch it will act as an event dumper, simply dumping the events it receives to standard out:

    $ celeryev -d
    -> celeryev: starting capture...
    casper.local [2010-06-04 10:42:07.020000] heartbeat
    casper.local [2010-06-04 10:42:14.750000] task received:
        tasks.add(61a68756-27f4-4879-b816-3cf815672b0e) args=[2, 2] kwargs={}
        eta=2010-06-04T10:42:16.669290, retries=0
    casper.local [2010-06-04 10:42:17.230000] task started
        tasks.add(61a68756-27f4-4879-b816-3cf815672b0e) args=[2, 2] kwargs={}
    casper.local [2010-06-04 10:42:17.960000] task succeeded:
        args=[2, 2] kwargs={} result=4, runtime=0.782663106918
    The fields here are, in order: *sender hostname*, *timestamp*, *event type* and
    *additional event fields*.
  • AMQP result backend: Now supports .ready(), .successful(), .result, .status, and even responds to changes in task state

  • New user guides:

  • celeryd: Standard out/error is now being redirected to the log file.

  • billiard has been moved back to the celery repository.

    Module name celery equivalent
    billiard.pool celery.concurrency.processes.pool
    billiard.serialization celery.serialization
    billiard.utils.functional celery.utils.functional

    The billiard distribution may be maintained, depending on interest.

  • now depends on carrot >= 0.10.5

  • now depends on pyparsing

  • celeryd: Added --purge as an alias to --discard.

  • celeryd: Ctrl+C (SIGINT) once does warm shutdown, hitting Ctrl+C twice forces termination.

  • Added support for using complex crontab-expressions in periodic tasks. For example, you can now use:

    >>> crontab(minute="*/15")

    or even:

    >>> crontab(minute="*/30", hour="8-17,1-2", day_of_week="thu-fri")

    See Periodic Tasks.

  • celeryd: Now waits for available pool processes before applying new tasks to the pool.

    This means it doesn’t have to wait for dozens of tasks to finish at shutdown because it has applied prefetched tasks without having any pool processes available to immediately accept them.

    See issue #122.

  • New built-in way to do task callbacks using subtask.

    See Sets of tasks, Subtasks and Callbacks for more information.

  • TaskSets can now contain several types of tasks.

    TaskSet has been refactored to use a new syntax, please see Sets of tasks, Subtasks and Callbacks for more information.

    The previous syntax is still supported, but will be deprecated in version 1.4.

  • TaskSet failed() result was incorrect.

    See issue #132.

  • Now creates different loggers per task class.

    See issue #129.

  • Missing queue definitions are now created automatically.

    You can disable this using the CELERY_CREATE_MISSING_QUEUES setting.

    The missing queues are created with the following options:

    CELERY_QUEUES[name] = {"exchange": name,
                           "exchange_type": "direct",
                           "routing_key": "name}

    This feature is added for easily setting up routing using the -Q option to celeryd:

    $ celeryd -Q video, image

    See the new routing section of the User Guide for more information: Routing Tasks.

  • New Task option: Task.queue

    If set, message options will be taken from the corresponding entry in CELERY_QUEUES. exchange, exchange_type and routing_key will be ignored

  • Added support for task soft and hard time limits.

    New settings added:


      Hard time limit. The worker processing the task will be killed and replaced with a new one when this is exceeded.


      Soft time limit. The celery.exceptions.SoftTimeLimitExceeded exception will be raised when this is exceeded. The task can catch this to e.g. clean up before the hard time limit comes.

    New command line arguments to celeryd added: --time-limit and --soft-time-limit.

    What’s left?

    This won’t work on platforms not supporting signals (and specifically the SIGUSR1 signal) yet. So an alternative the ability to disable the feature all together on nonconforming platforms must be implemented.

    Also when the hard time limit is exceeded, the task result should be a TimeLimitExceeded exception.

  • Test suite is now passing without a running broker, using the carrot in-memory backend.

  • Log output is now available in colors.

    Log level Color
    DEBUG Blue
    WARNING Yellow
    CRITICAL Magenta
    ERROR Red

    This is only enabled when the log output is a tty. You can explicitly enable/disable this feature using the CELERYD_LOG_COLOR setting.

  • Added support for task router classes (like the django multi-db routers)

    This is a single, or a list of routers to traverse when sending tasks. Dictionaries in this list converts to a celery.routes.MapRoute instance.


    >>> CELERY_ROUTES = {"": "default",
                         "mytasks.add": "cpu-bound",
                         "video.encode": {
                             "queue": "video",
                             "exchange": "media"
                             "routing_key": ""}}
    >>> CELERY_ROUTES = ("myapp.tasks.Router",
                         {"": "default})

    Where myapp.tasks.Router could be:

    class Router(object):
        def route_for_task(self, task, args=None, kwargs=None):
            if task == "":
                return "default"

    route_for_task may return a string or a dict. A string then means it’s a queue name in CELERY_QUEUES, a dict means it’s a custom route.

    When sending tasks, the routers are consulted in order. The first router that doesn’t return None is the route to use. The message options is then merged with the found route settings, where the routers settings have priority.

    Example if apply_async() has these arguments:

    >>> Task.apply_async(immediate=False, exchange="video",
    ...                  routing_key="video.compress")

    and a router returns:

    {"immediate": True,
     "exchange": "urgent"}

    the final message options will be:

    immediate=True, exchange="urgent", routing_key="video.compress"

    (and any default message options defined in the Task class)

  • New Task handler called after the task returns: after_return().

  • ExceptionInfo now passed to

    on_retry()/ on_failure() as einfo keyword argument.

  • celeryd: Added CELERYD_MAX_TASKS_PER_CHILD / --maxtasksperchild

    Defines the maximum number of tasks a pool worker can process before the process is terminated and replaced by a new one.

  • Revoked tasks now marked with state REVOKED, and result.get() will now raise TaskRevokedError.

  • now works as expected.

  • apply(throw=True) / CELERY_EAGER_PROPAGATES_EXCEPTIONS: Makes eager execution re-raise task errors.

  • New signal: worker_process_init: Sent inside the pool worker process at init.

  • celeryd -Q option: Ability to specify list of queues to use, disabling other configured queues.

    For example, if CELERY_QUEUES defines four queues: image, video, data and default, the following command would make celeryd only consume from the image and video queues:

    $ celeryd -Q image,video
  • celeryd: New return value for the revoke control command:

    Now returns:

    {"ok": "task $id revoked"}

    instead of True.

  • celeryd: Can now enable/disable events using remote control

    Example usage:

    >>> from celery.task.control import broadcast
    >>> broadcast("enable_events")
    >>> broadcast("disable_events")
  • Removed top-level tests directory. Test config now in celery.tests.config

    This means running the unit tests doesn’t require any special setup. celery/tests/__init__ now configures the CELERY_CONFIG_MODULE and CELERY_LOADER environment variables, so when nosetests imports that, the unit test environment is all set up.

    Before you run the tests you need to install the test requirements:

    $ pip install -r contrib/requirements/test.txt

    Running all tests:

    $ nosetests

    Specifying the tests to run:

    $ nosetests celery.tests.test_task

    Producing HTML coverage:

    $ nosetests --with-coverage3

    The coverage output is then located in celery/tests/cover/index.html.

  • celeryd: New option --version: Dump version info and exit.

  • celeryd-multi: Tool for shell scripts to start multiple workers.

Some examples:

# Advanced example with 10 workers:
#   * Three of the workers processes the images and video queue
#   * Two of the workers processes the data queue with loglevel DEBUG
#   * the rest processes the default' queue.
$ celeryd-multi start 10 -l INFO -Q:1-3 images,video -Q:4,5:data
    -Q default -L:4,5 DEBUG

# get commands to start 10 workers, with 3 processes each
$ celeryd-multi start 3 -c 3
celeryd -n celeryd1.myhost -c 3
celeryd -n celeryd2.myhost -c 3
celeryd- n celeryd3.myhost -c 3

# start 3 named workers
$ celeryd-multi start image video data -c 3
celeryd -n image.myhost -c 3
celeryd -n video.myhost -c 3
celeryd -n data.myhost -c 3

# specify custom hostname
$ celeryd-multi start 2 -n -c 3
celeryd -n -c 3
celeryd -n -c 3

# Additionl options are added to each celeryd',
# but you can also modify the options for ranges of or single workers

# 3 workers: Two with 3 processes, and one with 10 processes.
$ celeryd-multi start 3 -c 3 -c:1 10
celeryd -n celeryd1.myhost -c 10
celeryd -n celeryd2.myhost -c 3
celeryd -n celeryd3.myhost -c 3

# can also specify options for named workers
$ celeryd-multi start image video data -c 3 -c:image 10
celeryd -n image.myhost -c 10
celeryd -n video.myhost -c 3
celeryd -n data.myhost -c 3

# ranges and lists of workers in options is also allowed:
# (-c:1-3 can also be written as -c:1,2,3)
$ celeryd-multi start 5 -c 3  -c:1-3 10
celeryd-multi -n celeryd1.myhost -c 10
celeryd-multi -n celeryd2.myhost -c 10
celeryd-multi -n celeryd3.myhost -c 10
celeryd-multi -n celeryd4.myhost -c 3
celeryd-multi -n celeryd5.myhost -c 3

# lists also works with named workers
$ celeryd-multi start foo bar baz xuzzy -c 3 -c:foo,bar,baz 10
celeryd-multi -n foo.myhost -c 10
celeryd-multi -n bar.myhost -c 10
celeryd-multi -n baz.myhost -c 10
celeryd-multi -n xuzzy.myhost -c 3
  • The worker now calls the result backends process_cleanup method after task execution instead of before.
  • AMQP result backend now supports Pika.


release-date:2010-06-30 09:57 A.M CEST
  • RabbitMQ 1.8.0 has extended their exchange equivalence tests to include auto_delete and durable. This broke the AMQP backend.

    If you’ve already used the AMQP backend this means you have to delete the previous definitions:

    $ camqadm exchange.delete celeryresults


    $ python camqadm exchange.delete celeryresults


release-date:2010-06-01 02:36 P.M CEST


  • SIGINT/Ctrl+C killed the pool, abruptly terminating the currently executing tasks.

    Fixed by making the pool worker processes ignore SIGINT.

  • Should not close the consumers before the pool is terminated, just cancel the consumers.

    See issue #122.

  • Now depends on billiard >= 0.3.1

  • celeryd: Previously exceptions raised by worker components could stall startup, now it correctly logs the exceptions and shuts down.

  • celeryd: Prefetch counts was set too late. QoS is now set as early as possible, so celeryd can’t slurp in all the messages at start-up.


  • celery.contrib.abortable: Abortable tasks.

    Tasks that defines steps of execution, the task can then be aborted after each step has completed.

  • EventDispatcher: No longer creates AMQP channel if events are disabled

  • Added required RPM package names under [bdist_rpm] section, to support building RPMs from the sources using

  • Running unit tests: NOSE_VERBOSE environment var now enables verbose output from Nose.

  • celery.execute.apply(): Pass log file/log level arguments as task kwargs.

    See issue #110.

  • celery.execute.apply: Should return exception, not ExceptionInfo on error.

    See issue #111.

  • Added new entries to the FAQs:

    • Should I use retry or acks_late?
    • Can I execute a task by name?


release-date:2010-05-31 09:54 A.M CEST
  • Changelog merged with 1.0.5 as the release was never announced.


release-date:2010-05-15 03:00 P.M CEST

Important notes

  • Messages are now acknowledged just before the task function is executed.

    This is the behavior we’ve wanted all along, but couldn’t have because of limitations in the multiprocessing module. The previous behavior was not good, and the situation worsened with the release of 1.0.1, so this change will definitely improve reliability, performance and operations in general.

    For more information please see

  • Database result backend: result now explicitly sets null=True as django-picklefield version 0.1.5 changed the default behavior right under our noses :(


    This means those who created their celery tables (via syncdb or celeryinit) with picklefield versions >= 0.1.5 has to alter their tables to allow the result field to be NULL manually.


    ALTER TABLE celery_taskmeta MODIFY result TEXT NULL


    ALTER TABLE celery_taskmeta ALTER COLUMN result DROP NOT NULL
  • Removed Task.rate_limit_queue_type, as it was not really useful and made it harder to refactor some parts.

  • Now depends on carrot >= 0.10.4

  • Now depends on billiard >= 0.3.0


  • AMQP backend: Added timeout support for result.get() / result.wait().

  • New task option: Task.acks_late (default: CELERY_ACKS_LATE)

    Late ack means the task messages will be acknowledged after the task has been executed, not just before, which is the default behavior.


    This means the tasks may be executed twice if the worker crashes in mid-execution. Not acceptable for most applications, but desirable for others.

  • Added crontab-like scheduling to periodic tasks.

    Like a cron job, you can specify units of time of when you would like the task to execute. While not a full implementation of cron’s features, it should provide a fair degree of common scheduling needs.

    You can specify a minute (0-59), an hour (0-23), and/or a day of the week (0-6 where 0 is Sunday, or by names: sun, mon, tue, wed, thu, fri, sat).


    from celery.task.schedules import crontab
    from celery.decorators import periodic_task
    @periodic_task(run_every=crontab(hour=7, minute=30))
    def every_morning():
        print("Runs every morning at 7:30a.m")
    @periodic_task(run_every=crontab(hour=7, minute=30, day_of_week="mon"))
    def every_monday_morning():
        print("Run every monday morning at 7:30a.m")
    def every_hour():
        print("Runs every hour on the clock. e.g. 1:30, 2:30, 3:30 etc.")


    This a late addition. While we have unittests, due to the nature of this feature we haven’t been able to completely test this in practice, so consider this experimental.

  • TaskPool.apply_async: Now supports the accept_callback argument.

  • apply_async: Now raises ValueError if task args is not a list, or kwargs is not a tuple (Issue #95).

  • Task.max_retries can now be None, which means it will retry forever.

  • Celerybeat: Now reuses the same connection when publishing large sets of tasks.

  • Modified the task locking example in the documentation to use cache.add for atomic locking.

  • Added experimental support for a started status on tasks.

    If Task.track_started is enabled the task will report its status as “started” when the task is executed by a worker.

    The default value is False as the normal behaviour is to not report that level of granularity. Tasks are either pending, finished, or waiting to be retried. Having a “started” status can be useful for when there are long running tasks and there is a need to report which task is currently running.

    The global default can be overridden by the CELERY_TRACK_STARTED setting.

  • User Guide: New section Tips and Best Practices.

    Contributions welcome!

Remote control commands

  • Remote control commands can now send replies back to the caller.

    Existing commands has been improved to send replies, and the client interface in celery.task.control has new keyword arguments: reply, timeout and limit. Where reply means it will wait for replies, timeout is the time in seconds to stop waiting for replies, and limit is the maximum number of replies to get.

    By default, it will wait for as many replies as possible for one second.

    • rate_limit(task_name, destination=all, reply=False, timeout=1, limit=0)

      Worker returns {"ok": message} on success, or {"failure": message} on failure.

      >>> from celery.task.control import rate_limit
      >>> rate_limit("tasks.add", "10/s", reply=True)
      [{'worker1': {'ok': 'new rate limit set successfully'}},
       {'worker2': {'ok': 'new rate limit set successfully'}}]
    • ping(destination=all, reply=False, timeout=1, limit=0)

      Worker returns the simple message "pong".

      >>> from celery.task.control import ping
      >>> ping(reply=True)
      [{'worker1': 'pong'},
       {'worker2': 'pong'},
    • revoke(destination=all, reply=False, timeout=1, limit=0)

      Worker simply returns True.

      >>> from celery.task.control import revoke
      >>> revoke("419e46eb-cf6a-4271-86a8-442b7124132c", reply=True)
      [{'worker1': True},
       {'worker2'; True}]
  • You can now add your own remote control commands!

    Remote control commands are functions registered in the command registry. Registering a command is done using celery.worker.control.Panel.register():

    from celery.task.control import Panel
    def reset_broker_connection(panel, **kwargs):
        return {"ok": "connection re-established"}

    With this module imported in the worker, you can launch the command using celery.task.control.broadcast:

    >>> from celery.task.control import broadcast
    >>> broadcast("reset_broker_connection", reply=True)
    [{'worker1': {'ok': 'connection re-established'},
     {'worker2': {'ok': 'connection re-established'}}]

    TIP You can choose the worker(s) to receive the command by using the destination argument:

    >>> broadcast("reset_broker_connection", destination=["worker1"])
    [{'worker1': {'ok': 'connection re-established'}]
  • New remote control command: dump_reserved

    Dumps tasks reserved by the worker, waiting to be executed:

    >>> from celery.task.control import broadcast
    >>> broadcast("dump_reserved", reply=True)
    [{'myworker1': [<TaskRequest ....>]}]
  • New remote control command: dump_schedule

    Dumps the workers currently registered ETA schedule. These are tasks with an eta (or countdown) argument waiting to be executed by the worker.

    >>> from celery.task.control import broadcast
    >>> broadcast("dump_schedule", reply=True)
    [{'w1': []},
     {'w3': []},
     {'w2': ['0. 2010-05-12 11:06:00 pri0 <TaskRequest
                 args:"(<Feeds freq_max:3600 freq_min:60
                               start:2184.0 stop:3276.0>,)",
                 kwargs:"{'page': 2}"}>']},
     {'w4': ['0. 2010-05-12 11:00:00 pri0 <TaskRequest
                 args:"(<Feeds freq_max:3600 freq_min:60
                               start:1092.0 stop:2184.0>,)",
                 kwargs:"{\'page\': 1}"}>',
            '1. 2010-05-12 11:12:00 pri0 <TaskRequest
                 args:"(<Feeds freq_max:3600 freq_min:60
                               start:3276.0 stop:4365>,)",
                 kwargs:"{\'page\': 3}"}>']}]


  • Mediator thread no longer blocks for more than 1 second.

    With rate limits enabled and when there was a lot of remaining time, the mediator thread could block shutdown (and potentially block other jobs from coming in).

  • Remote rate limits was not properly applied (Issue #98).

  • Now handles exceptions with Unicode messages correctly in TaskRequest.on_failure.

  • Database backend: TaskMeta.result: default value should be None not empty string.


release-date:2010-03-31 12:50 P.M CET
  • Deprecated: CELERY_BACKEND, please use CELERY_RESULT_BACKEND instead.

  • We now use a custom logger in tasks. This logger supports task magic keyword arguments in formats.

    The default format for tasks (CELERYD_TASK_LOG_FORMAT) now includes the id and the name of tasks so the origin of task log messages can easily be traced.

    Example output::
    [2010-03-25 13:11:20,317: INFO/PoolWorker-1]

    [tasks.add(a6e1c5ad-60d9-42a0-8b24-9e39363125a4)] Hello from add

    To revert to the previous behavior you can set:

        [%(asctime)s: %(levelname)s/%(processName)s] %(message)s
  • Unit tests: Don’t disable the django test database tear down, instead fixed the underlying issue which was caused by modifications to the DATABASE_NAME setting (Issue #82).

  • Django Loader: New config CELERY_DB_REUSE_MAX (max number of tasks to reuse the same database connection)

    The default is to use a new connection for every task. We would very much like to reuse the connection, but a safe number of reuses is not known, and we don’t have any way to handle the errors that might happen, which may even be database dependent.


  • celeryd: The worker components are now configurable: CELERYD_POOL, CELERYD_LISTENER, CELERYD_MEDIATOR, and CELERYD_ETA_SCHEDULER.

    The default configuration is as follows:

    CELERYD_POOL = "celery.concurrency.processes.TaskPool"
    CELERYD_MEDIATOR = "celery.worker.controllers.Mediator"
    CELERYD_ETA_SCHEDULER = "celery.worker.controllers.ScheduleController"
    CELERYD_LISTENER = "celery.worker.listener.CarrotListener"

    The CELERYD_POOL setting makes it easy to swap out the multiprocessing pool with a threaded pool, or how about a twisted/eventlet pool?

    Consider the competition for the first pool plug-in started!

  • Debian init scripts: Use -a not && (Issue #82).

  • Debian init scripts: Now always preserves $CELERYD_OPTS from the /etc/default/celeryd and /etc/default/celerybeat.

  • celery.beat.Scheduler: Fixed a bug where the schedule was not properly flushed to disk if the schedule had not been properly initialized.

  • celerybeat: Now syncs the schedule to disk when receiving the SIGTERM and SIGINT signals.

  • Control commands: Make sure keywords arguments are not in Unicode.

  • ETA scheduler: Was missing a logger object, so the scheduler crashed when trying to log that a task had been revoked.

  • management.commands.camqadm: Fixed typo camqpadm -> camqadm (Issue #83).

  • PeriodicTask.delta_resolution: Was not working for days and hours, now fixed by rounding to the nearest day/hour.

  • Fixed a potential infinite loop in BaseAsyncResult.__eq__, although there is no evidence that it has ever been triggered.

  • celeryd: Now handles messages with encoding problems by acking them and emitting an error message.


release-date:2010-02-24 07:05 P.M CET
  • Tasks are now acknowledged early instead of late.

    This is done because messages can only be acknowledged within the same connection channel, so if the connection is lost we would have to refetch the message again to acknowledge it.

    This might or might not affect you, but mostly those running tasks with a really long execution time are affected, as all tasks that has made it all the way into the pool needs to be executed before the worker can safely terminate (this is at most the number of pool workers, multiplied by the CELERYD_PREFETCH_MULTIPLIER setting.)

    We multiply the prefetch count by default to increase the performance at times with bursts of tasks with a short execution time. If this doesn’t apply to your use case, you should be able to set the prefetch multiplier to zero, without sacrificing performance.


    A patch to multiprocessing is currently being worked on, this patch would enable us to use a better solution, and is scheduled for inclusion in the 2.0.0 release.

  • celeryd now shutdowns cleanly when receiving the SIGTERM signal.

  • celeryd now does a cold shutdown if the SIGINT signal is received (Ctrl+C), this means it tries to terminate as soon as possible.

  • Caching of results now moved to the base backend classes, so no need to implement this functionality in the base classes.

  • Caches are now also limited in size, so their memory usage doesn’t grow out of control.

    You can set the maximum number of results the cache can hold using the CELERY_MAX_CACHED_RESULTS setting (the default is five thousand results). In addition, you can refetch already retrieved results using backend.reload_task_result + backend.reload_taskset_result (that’s for those who want to send results incrementally).

  • celeryd now works on Windows again.


    If you’re using Celery with Django, you can’t use project.settings as the settings module name, but the following should work:

    $ python celeryd --settings=settings
  • Execution: .messaging.TaskPublisher.send_task now incorporates all the functionality apply_async previously did.

    Like converting countdowns to eta, so celery.execute.apply_async() is now simply a convenient front-end to celery.messaging.TaskPublisher.send_task(), using the task classes default options.

    Also celery.execute.send_task() has been introduced, which can apply tasks using just the task name (useful if the client does not have the destination task in its task registry).


    >>> from celery.execute import send_task
    >>> result = send_task("", args=[], kwargs={})
    >>> result.get()
  • camqadm: This is a new utility for command line access to the AMQP API.

    Excellent for deleting queues/bindings/exchanges, experimentation and testing:

    $ camqadm
    1> help

    Gives an interactive shell, type help for a list of commands.

    When using Django, use the management command instead:

    $ python camqadm
    1> help
  • Redis result backend: To conform to recent Redis API changes, the following settings has been deprecated:


    These will emit a DeprecationWarning if used.

    A REDIS_PASSWORD setting has been added, so you can use the new simple authentication mechanism in Redis.

  • The redis result backend no longer calls SAVE when disconnecting, as this is apparently better handled by Redis itself.

  • If settings.DEBUG is on, celeryd now warns about the possible memory leak it can result in.

  • The ETA scheduler now sleeps at most two seconds between iterations.

  • The ETA scheduler now deletes any revoked tasks it might encounter.

    As revokes are not yet persistent, this is done to make sure the task is revoked even though it’s currently being hold because its eta is e.g. a week into the future.

  • The task_id argument is now respected even if the task is executed eagerly (either using apply, or CELERY_ALWAYS_EAGER).

  • The internal queues are now cleared if the connection is reset.

  • New magic keyword argument: delivery_info.

    Used by retry() to resend the task to its original destination using the same exchange/routing_key.

  • Events: Fields was not passed by .send() (fixes the UUID key errors in celerymon)

  • Added --schedule/-s option to celeryd, so it is possible to specify a custom schedule filename when using an embedded celerybeat server (the -B/--beat) option.

  • Better Python 2.4 compatibility. The test suite now passes.

  • task decorators: Now preserve docstring as cls.__doc__, (was previously copied to

  • The testproj directory has been renamed to tests and we’re now using nose + django-nose for test discovery, and unittest2 for test cases.

  • New pip requirements files available in contrib/requirements.

  • TaskPublisher: Declarations are now done once (per process).

  • Added Task.delivery_mode and the CELERY_DEFAULT_DELIVERY_MODE setting.

    These can be used to mark messages non-persistent (i.e. so they are lost if the broker is restarted).

  • Now have our own ImproperlyConfigured exception, instead of using the Django one.

  • Improvements to the Debian init scripts: Shows an error if the program is not executable. Does not modify CELERYD when using django with virtualenv.


release-date:2010-02-10 04:00 P.M CET

Backward incompatible changes

  • Celery does not support detaching anymore, so you have to use the tools available on your platform, or something like Supervisord to make celeryd/celerybeat/celerymon into background processes.

    We’ve had too many problems with celeryd daemonizing itself, so it was decided it has to be removed. Example startup scripts has been added to contrib/:

    • Debian, Ubuntu, (start-stop-daemon)

      contrib/debian/init.d/celeryd contrib/debian/init.d/celerybeat

    • Mac OS X launchd

      contrib/mac/org.celeryq.celeryd.plist contrib/mac/org.celeryq.celerybeat.plist contrib/mac/org.celeryq.celerymon.plist

    • Supervisord (


    In addition to --detach, the following program arguments has been removed: --uid, --gid, --workdir, --chroot, --pidfile, --umask. All good daemonization tools should support equivalent functionality, so don’t worry.

    Also the following configuration keys has been removed: CELERYD_PID_FILE, CELERYBEAT_PID_FILE, CELERYMON_PID_FILE.

  • Default celeryd loglevel is now WARN, to enable the previous log level start celeryd with --loglevel=INFO.

  • Tasks are automatically registered.

    This means you no longer have to register your tasks manually. You don’t have to change your old code right away, as it doesn’t matter if a task is registered twice.

    If you don’t want your task to be automatically registered you can set the abstract attribute

    class MyTask(Task):
        abstract = True

    By using abstract only tasks subclassing this task will be automatically registered (this works like the Django ORM).

    If you don’t want subclasses to be registered either, you can set the autoregister attribute to False.

    Incidentally, this change also fixes the problems with automatic name assignment and relative imports. So you also don’t have to specify a task name anymore if you use relative imports.

  • You can no longer use regular functions as tasks.

    This change was added because it makes the internals a lot more clean and simple. However, you can now turn functions into tasks by using the @task decorator:

    from celery.decorators import task
    def add(x, y):
        return x + y

    See also

    Tasks for more information about the task decorators.

  • The periodic task system has been rewritten to a centralized solution.

    This means celeryd no longer schedules periodic tasks by default, but a new daemon has been introduced: celerybeat.

    To launch the periodic task scheduler you have to run celerybeat:

    $ celerybeat

    Make sure this is running on one server only, if you run it twice, all periodic tasks will also be executed twice.

    If you only have one worker server you can embed it into celeryd like this:

    $ celeryd --beat # Embed celerybeat in celeryd.
  • The supervisor has been removed.

    This means the -S and --supervised options to celeryd is no longer supported. Please use something like instead.

  • TaskSet.join has been removed, use TaskSetResult.join instead.

  • The task status "DONE" has been renamed to “SUCCESS”.

  • AsyncResult.is_done has been removed, use AsyncResult.successful instead.

  • The worker no longer stores errors if Task.ignore_result is set, to revert to the previous behaviour set CELERY_STORE_ERRORS_EVEN_IF_IGNORED to True.

  • The statistics functionality has been removed in favor of events, so the -S and –statistics` switches has been removed.

  • The module celery.task.strategy has been removed.

  • celery.discovery has been removed, and it’s autodiscover function is now in celery.loaders.djangoapp. Reason: Internal API.

  • The CELERY_LOADER environment variable now needs loader class name in addition to module name,

    E.g. where you previously had: “celery.loaders.default”, you now need “celery.loaders.default.Loader”, using the previous syntax will result in a DeprecationWarning.

  • Detecting the loader is now lazy, and so is not done when importing celery.loaders.

    To make this happen celery.loaders.settings has been renamed to load_settings and is now a function returning the settings object. celery.loaders.current_loader is now also a function, returning the current loader.


    loader = current_loader

    needs to be changed to:

    loader = current_loader()


  • The following configuration variables has been renamed and will be deprecated in v2.0:

  • The public API names in celery.conf has also changed to a consistent naming scheme.

  • We now support consuming from an arbitrary number of queues.

    To do this we had to rename the configuration syntax. If you use any of the custom AMQP routing options (queue/exchange/routing_key, etc.), you should read the new FAQ entry:

    The previous syntax is deprecated and scheduled for removal in v2.0.

  • has been renamed to TaskSet.apply_async. has now been deprecated, and is scheduled for removal in v2.0.


  • Rate limiting support (per task type, or globally).

  • New periodic task system.

  • Automatic registration.

  • New cool task decorator syntax.

  • celeryd now sends events if enabled with the -E argument.

    Excellent for monitoring tools, one is already in the making (

    Current events include: worker-heartbeat, task-[received/succeeded/failed/retried], worker-online, worker-offline.

  • You can now delete (revoke) tasks that has already been applied.

  • You can now set the hostname celeryd identifies as using the --hostname argument.

  • Cache backend now respects the CELERY_TASK_RESULT_EXPIRES setting.

  • Message format has been standardized and now uses ISO-8601 format for dates instead of datetime.

  • celeryd now responds to the SIGHUP signal by restarting itself.

  • Periodic tasks are now scheduled on the clock.

    I.e. timedelta(hours=1) means every hour at :00 minutes, not every hour from the server starts. To revert to the previous behaviour you can set PeriodicTask.relative = True.

  • Now supports passing execute options to a TaskSets list of args, e.g.:

    >>> ts = TaskSet(add, [([2, 2], {}, {"countdown": 1}),
    ...                   ([4, 4], {}, {"countdown": 2}),
    ...                   ([8, 8], {}, {"countdown": 3})])
  • Got a 3x performance gain by setting the prefetch count to four times the concurrency, (from an average task round-trip of 0.1s to 0.03s!).

    A new setting has been added: CELERYD_PREFETCH_MULTIPLIER, which is set to 4 by default.

  • Improved support for webhook tasks. is now deprecated, replaced with the new and shiny celery.task.http. With more reflective names, sensible interface, and it’s possible to override the methods used to perform HTTP requests.

  • The results of task sets are now cached by storing it in the result backend.


  • Now depends on carrot >= 0.8.1

  • New dependencies: billiard, python-dateutil, django-picklefield

  • No longer depends on python-daemon

  • The uuid distribution is added as a dependency when running Python 2.4.

  • Now remembers the previously detected loader by keeping it in the CELERY_LOADER environment variable.

    This may help on windows where fork emulation is used.

  • ETA no longer sends datetime objects, but uses ISO 8601 date format in a string for better compatibility with other platforms.

  • No longer sends error mails for retried tasks.

  • Task can now override the backend used to store results.

  • Refactored the ExecuteWrapper, apply and CELERY_ALWAYS_EAGER now also executes the task callbacks and signals.

  • Now using a proper scheduler for the tasks with an ETA.

    This means waiting eta tasks are sorted by time, so we don’t have to poll the whole list all the time.

  • Now also imports modules listed in CELERY_IMPORTS when running with django (as documented).

  • Log level for stdout/stderr changed from INFO to ERROR

  • ImportErrors are now properly propagated when autodiscovering tasks.

  • You can now use celery.messaging.establish_connection to establish a connection to the broker.

  • When running as a separate service the periodic task scheduler does some smart moves to not poll too regularly.

    If you need faster poll times you can lower the value of CELERYBEAT_MAX_LOOP_INTERVAL.

  • You can now change periodic task intervals at runtime, by making run_every a property, or subclassing PeriodicTask.is_due.

  • The worker now supports control commands enabled through the use of a broadcast queue, you can remotely revoke tasks or set the rate limit for a task type. See celery.task.control.

  • The services now sets informative process names (as shown in ps listings) if the setproctitle module is installed.

  • celery.exceptions.NotRegistered now inherits from KeyError, and TaskRegistry.__getitem__``+``pop raises NotRegistered instead

  • You can set the loader via the CELERY_LOADER environment variable.

  • You can now set CELERY_IGNORE_RESULT to ignore task results by default (if enabled, tasks doesn’t save results or errors to the backend used).

  • celeryd now correctly handles malformed messages by throwing away and acknowledging the message, instead of crashing.


  • Fixed a race condition that could happen while storing task results in the database.


  • Reference now split into two sections; API reference and internal module reference.


release-date:2010-02-05 01:52 P.M CEST
  • Now emits a warning if the –detach argument is used. –detach should not be used anymore, as it has several not easily fixed bugs related to it. Instead, use something like start-stop-daemon, Supervisord or launchd (os x).
  • Make sure logger class is process aware, even if running Python >= 2.6.
  • Error e-mails are not sent anymore when the task is retried.


release-date:2009-12-22 09:43 A.M CEST
  • Fixed a possible race condition that could happen when storing/querying task results using the database backend.
  • Now has console script entry points in the file, so tools like Buildout will correctly install the programs celeryd and celeryinit.


release-date:2009-11-20 03:40 P.M CEST
  • QOS Prefetch count was not applied properly, as it was set for every message received (which apparently behaves like, “receive one more”), instead of only set when our wanted value changed.


release-date:2009-11-16 05:21 P.M CEST

Very important note

This release (with carrot 0.8.0) enables AMQP QoS (quality of service), which means the workers will only receive as many messages as it can handle at a time. As with any release, you should test this version upgrade on your development servers before rolling it out to production!

Important changes

  • If you’re using Python < 2.6 and you use the multiprocessing backport, then multiprocessing version is required.

  • All AMQP_* settings has been renamed to BROKER_*, and in addition AMQP_SERVER has been renamed to BROKER_HOST, so before where you had:

    AMQP_SERVER = "localhost"
    AMQP_PORT = 5678
    AMQP_USER = "myuser"
    AMQP_PASSWORD = "mypassword"
    AMQP_VHOST = "celery"

    You need to change that to:

    BROKER_HOST = "localhost"
    BROKER_PORT = 5678
    BROKER_USER = "myuser"
    BROKER_PASSWORD = "mypassword"
    BROKER_VHOST = "celery"
  • Custom carrot backends now need to include the backend class name, so before where you had:

    CARROT_BACKEND = "mycustom.backend.module"

    you need to change it to:

    CARROT_BACKEND = "mycustom.backend.module.Backend"

    where Backend is the class name. This is probably "Backend", as that was the previously implied name.

  • New version requirement for carrot: 0.8.0


  • Incorporated the multiprocessing backport patch that fixes the processName error.
  • Ignore the result of PeriodicTask’s by default.
  • Added a Redis result store backend
  • Allow /etc/default/celeryd to define additional options for the celeryd init script.
  • MongoDB periodic tasks issue when using different time than UTC fixed.
  • Windows specific: Negate test for available os.fork (thanks miracle2k)
  • Now tried to handle broken PID files.
  • Added a Django test runner to contrib that sets CELERY_ALWAYS_EAGER = True for testing with the database backend.
  • Added a CELERY_CACHE_BACKEND setting for using something other than the django-global cache backend.
  • Use custom implementation of functools.partial (curry) for Python 2.4 support (Probably still problems with running on 2.4, but it will eventually be supported)
  • Prepare exception to pickle when saving RETRY status for all backends.
  • SQLite no concurrency limit should only be effective if the database backend is used.


release-date:2009-09-22 03:06 P.M CEST

Backward incompatible changes

  • Add traceback to result value on failure.


    If you use the database backend you have to re-create the database table celery_taskmeta.

    Contact the Mailing list or IRC channel for help doing this.

  • Database tables are now only created if the database backend is used, so if you change back to the database backend at some point, be sure to initialize tables (django: syncdb, python: celeryinit).


    This is only applies if using Django version 1.1 or higher.

  • Now depends on carrot version 0.6.0.

  • Now depends on python-daemon 1.4.8

Important changes

  • Celery can now be used in pure Python (outside of a Django project).

    This means celery is no longer Django specific.

    For more information see the FAQ entry Is Celery for Django only?.

  • Celery now supports task retries.

    See Cookbook: Retrying Tasks for more information.

  • We now have an AMQP result store backend.

    It uses messages to publish task return value and status. And it’s incredibly fast!

    See issue #6 for more info!

  • AMQP QoS (prefetch count) implemented:

    This to not receive more messages than we can handle.

  • Now redirects stdout/stderr to the celeryd log file when detached

  • Now uses inspect.getargspec to only pass default arguments

    the task supports.

  • Add Task.on_success, .on_retry, .on_failure handlers
    See celery.task.base.Task.on_success(),

    celery.task.base.Task.on_retry(), celery.task.base.Task.on_failure(),

  • celery.utils.gen_unique_id: Workaround for

  • You can now customize what happens at worker start, at process init, etc.,

    by creating your own loaders. (see celery.loaders.default, celery.loaders.djangoapp, celery.loaders.)

  • Support for multiple AMQP exchanges and queues.

    This feature misses documentation and tests, so anyone interested is encouraged to improve this situation.

  • celeryd now survives a restart of the AMQP server!

    Automatically re-establish AMQP broker connection if it’s lost.

    New settings:


      Set to True to enable connection retries.


      Maximum number of restarts before we give up. Default: 100.


  • Fix an incompatibility between python-daemon and multiprocessing,

    which resulted in the [Errno 10] No child processes problem when detaching.

  • Fixed a possible DjangoUnicodeDecodeError being raised when saving pickled

    data to Django`s memcached cache backend.

  • Better Windows compatibility.

  • New version of the pickled field (taken from

  • New signals introduced: task_sent, task_prerun and

    task_postrun, see celery.signals for more information.

  • TaskSetResult.join caused TypeError when timeout=None.

    Thanks Jerzy Kozera. Closes #31

  • views.apply should return HttpResponse instance.

    Thanks to Jerzy Kozera. Closes #32

  • PeriodicTask: Save conversion of run_every from int

    to timedelta to the class attribute instead of on the instance.

  • Exceptions has been moved to celery.exceptions, but are still

    available in the previous module.

  • Try to rollback transaction and retry saving result if an error happens

    while setting task status with the database backend.

  • jail() refactored into celery.execute.ExecuteWrapper.

  • views.apply now correctly sets mime-type to “application/json”

  • views.task_status now returns exception if state is RETRY

  • views.task_status now returns traceback if state is FAILURE

    or RETRY

  • Documented default task arguments.

  • Add a sensible __repr__ to ExceptionInfo for easier debugging

  • Fix documentation typo .. import map -> .. import dmap.

    Thanks to mikedizon


release-date:2009-08-07 06:54 A.M CET

Important changes

  • Fixed a bug where tasks raising unpickleable exceptions crashed pool

    workers. So if you’ve had pool workers mysteriously disappearing, or problems with celeryd stopping working, this has been fixed in this version.

  • Fixed a race condition with periodic tasks.

  • The task pool is now supervised, so if a pool worker crashes,

    goes away or stops responding, it is automatically replaced with a new one.

  • is now automatically generated out of class module+name, e.g.

    "djangotwitter.tasks.UpdateStatusesTask". Very convenient. No idea why we didn’t do this before. Some documentation is updated to not manually specify a task name.


  • Tested with Django 1.1

  • New Tutorial: Creating a click counter using carrot and celery

  • Database entries for periodic tasks are now created at celeryd

    startup instead of for each check (which has been a forgotten TODO/XXX in the code for a long time)

  • New settings variable: CELERY_TASK_RESULT_EXPIRES

    Time (in seconds, or a datetime.timedelta object) for when after stored task results are deleted. For the moment this only works for the database backend.

  • celeryd now emits a debug log message for which periodic tasks

    has been launched.

  • The periodic task table is now locked for reading while getting

    periodic task status. (MySQL only so far, seeking patches for other engines)

  • A lot more debugging information is now available by turning on the

    DEBUG log level (–loglevel=DEBUG).

  • Functions/methods with a timeout argument now works correctly.

  • New: celery.strategy.even_time_distribution:

    With an iterator yielding task args, kwargs tuples, evenly distribute the processing of its tasks throughout the time window available.

  • Log message Unknown task ignored... now has log level ERROR

  • Log message "Got task from broker" is now emitted for all tasks, even if

    the task has an ETA (estimated time of arrival). Also the message now includes the ETA for the task (if any).

  • Acknowledgement now happens in the pool callback. Can’t do ack in the job

    target, as it’s not pickleable (can’t share AMQP connection, etc.)).

  • Added note about .delay hanging in README

  • Tests now passing in Django 1.1

  • Fixed discovery to make sure app is in INSTALLED_APPS

  • Previously overridden pool behavior (process reap, wait until pool worker

    available, etc.) is now handled by multiprocessing.Pool itself.

  • Convert statistics data to Unicode for use as kwargs. Thanks Lucy!


release-date:2009-07-02 01:42 P.M CET
  • Fixed a bug with parsing the message options (mandatory, routing_key, priority, immediate)


release-date:2009-07-01 07:29 P.M CET
  • Adds eager execution. celery.execute.apply`|`Task.apply executes the function blocking until the task is done, for API compatibility it returns an celery.result.EagerResult instance. You can configure celery to always run tasks locally by setting the CELERY_ALWAYS_EAGER setting to True.
  • Now depends on anyjson.
  • 99% coverage using python coverage 3.0.


release-date:2009-06-25 08:42 P.M CET
  • New arguments to apply_async (the advanced version of delay_task), countdown and eta;

    >>> # Run 10 seconds into the future.
    >>> res = apply_async(MyTask, countdown=10);
    >>> # Run 1 day from now
    >>> res = apply_async(MyTask,
    ...          + timedelta(days=1))
  • Now unlinks stale PID files

  • Lots of more tests.

  • Now compatible with carrot >= 0.5.0.

  • IMPORTANT The subtask_ids attribute on the TaskSetResult instance has been removed. To get this information instead use:

    >>> subtask_ids = [subtask.task_id for subtask in ts_res.subtasks]
  • now respects extra message options from the task class.

  • Task: Add attribute ignore_result: Don’t store the status and return value. This means you can’t use the celery.result.AsyncResult to check if the task is done, or get its return value. Only use if you need the performance and is able live without these features. Any exceptions raised will store the return value/status as usual.

  • Task: Add attribute disable_error_emails to disable sending error emails for that task.

  • Should now work on Windows (although running in the background won’t work, so using the --detach argument results in an exception being raised.)

  • Added support for statistics for profiling and monitoring. To start sending statistics start celeryd with the --statistics option. Then after a while you can dump the results by running python celerystats. See celery.monitoring for more information.

  • The celery daemon can now be supervised (i.e. it is automatically restarted if it crashes). To use this start celeryd with the --supervised option (or alternatively -S).

  • views.apply: View applying a task. Example


    Use with caution! Do not expose this URL to the public without first ensuring that your code is safe!

  • Refactored celery.task. It’s now split into three modules:

    • celery.task

      Contains apply_async, delay_task, discard_all, and task shortcuts, plus imports objects from celery.task.base and celery.task.builtins

    • celery.task.base

      Contains task base classes: Task, PeriodicTask, TaskSet, AsynchronousMapTask, ExecuteRemoteTask.

    • celery.task.builtins

      Built-in tasks: PingTask, DeleteExpiredTaskMetaTask.


release-date:2008-06-16 11:41 P.M CET
  • IMPORTANT Now uses AMQP`s basic.consume instead of basic.get. This means we’re no longer polling the broker for new messages.

  • IMPORTANT Default concurrency limit is now set to the number of CPUs available on the system.

  • IMPORTANT tasks.register: Renamed task_name argument to name, so

    >>> tasks.register(func, task_name="mytask")

    has to be replaced with:

    >>> tasks.register(func, name="mytask")
  • The daemon now correctly runs if the pidlock is stale.

  • Now compatible with carrot 0.4.5

  • Default AMQP connection timeout is now 4 seconds.

  • was always returning True.

  • Only use README as long_description if the file exists so easy_install doesn’t break.

  • celery.view: JSON responses now properly set its mime-type.

  • apply_async now has a connection keyword argument so you can re-use the same AMQP connection if you want to execute more than one task.

  • Handle failures in task_status view such that it won’t throw 500s.

  • Fixed typo AMQP_SERVER in documentation to AMQP_HOST.

  • Worker exception e-mails sent to administrators now works properly.

  • No longer depends on django, so installing celery won’t affect the preferred Django version installed.

  • Now works with PostgreSQL (psycopg2) again by registering the PickledObject field.

  • celeryd: Added --detach option as an alias to --daemon, and it’s the term used in the documentation from now on.

  • Make sure the pool and periodic task worker thread is terminated properly at exit. (So Ctrl-C works again).

  • Now depends on python-daemon.

  • Removed dependency to simplejson

  • Cache Backend: Re-establishes connection for every task process if the Django cache backend is memcached/libmemcached.

  • Tyrant Backend: Now re-establishes the connection for every task executed.


release-date:2009-06-08 01:07 P.M CET
  • The PeriodicWorkController now sleeps for 1 second between checking for periodic tasks to execute.


release-date:2009-06-08 01:07 P.M CET
  • celeryd: Added option --discard: Discard (delete!) all waiting messages in the queue.
  • celeryd: The --wakeup-after option was not handled as a float.


release-date:2009-06-08 01:07 P.M CET
  • The PeriodicTask` worker is now running in its own thread instead of blocking the TaskController loop.
  • Default QUEUE_WAKEUP_AFTER has been lowered to 0.1 (was 0.3)


release-date:2009-06-08 12:41 P.M CET


This is a development version, for the stable release, please see versions 0.2.x.

VERY IMPORTANT: Pickle is now the encoder used for serializing task arguments, so be sure to flush your task queue before you upgrade.

  • IMPORTANT now returns a celery.result.TaskSetResult instance, which lets you inspect the status and return values of a taskset as it was a single entity.

  • IMPORTANT Celery now depends on carrot >= 0.4.1.

  • The celery daemon now sends task errors to the registered admin e-mails. To turn off this feature, set SEND_CELERY_TASK_ERROR_EMAILS to False in your Thanks to Grégoire Cachet.

  • You can now run the celery daemon by using

    $ python celeryd

    Thanks to Grégoire Cachet.

  • Added support for message priorities, topic exchanges, custom routing keys for tasks. This means we have introduced celery.task.apply_async, a new way of executing tasks.

    You can use celery.task.delay and celery.Task.delay like usual, but if you want greater control over the message sent, you want celery.task.apply_async and celery.Task.apply_async.

    This also means the AMQP configuration has changed. Some settings has been renamed, while others are new:


    See the entry Can I send some tasks to only some servers? in the FAQ for more information.

  • Task errors are now logged using log level ERROR instead of INFO, and stacktraces are dumped. Thanks to Grégoire Cachet.
  • Make every new worker process re-establish it’s Django DB connection, this solving the “MySQL connection died?” exceptions. Thanks to Vitaly Babiy and Jirka Vejrazka.
  • IMPORTANT Now using pickle to encode task arguments. This means you now can pass complex python objects to tasks as arguments.
  • Removed dependency to yadayada.
  • Added a FAQ, see docs/faq.rst.
  • Now converts any Unicode keys in task kwargs to regular strings. Thanks Vitaly Babiy.
  • Renamed the TaskDaemon to WorkController.
  • celery.datastructures.TaskProcessQueue is now renamed to celery.pool.TaskPool.
  • The pool algorithm has been refactored for greater performance and stability.


release-date:2009-05-20 05:14 P.M CET
  • Final release of 0.2.0
  • Compatible with carrot version 0.4.0.
  • Fixes some syntax errors related to fetching results from the database backend.


release-date:2009-05-20 05:14 P.M CET
  • Internal release. Improved handling of unpickleable exceptions, get_result now tries to recreate something looking like the original exception.


release-date:2009-05-20 01:56 P.M CET
  • Now handles unpickleable exceptions (like the dynamically generated subclasses of django.core.exception.MultipleObjectsReturned).


release-date:2009-05-20 12:33 P.M CET
  • It’s getting quite stable, with a lot of new features, so bump version to 0.2. This is a pre-release.
  • celery.task.mark_as_read() and celery.task.mark_as_failure() has been removed. Use celery.backends.default_backend.mark_as_read(), and celery.backends.default_backend.mark_as_failure() instead.


release-date:2009-05-19 04:13 P.M CET
  • The celery daemon was leaking AMQP connections, this should be fixed, if you have any problems with too many files open (like emfile errors in rabbit.log, please contact us!


release-date:2009-05-19 01:08 P.M CET
  • Fixed a syntax error in the TaskSet class. (No such variable TimeOutError).


release-date:2009-05-19 12:36 P.M CET
  • Forgot to add yadayada to install requirements.

  • Now deletes all expired task results, not just those marked as done.

  • Able to load the Tokyo Tyrant backend class without django configuration, can specify tyrant settings directly in the class constructor.

  • Improved API documentation

  • Now using the Sphinx documentation system, you can build the html documentation by doing

    $ cd docs
    $ make html

    and the result will be in docs/.build/html.


release-date:2009-05-18 04:38 P.M CET
  • delay_task() etc. now returns celery.task.AsyncResult object, which lets you check the result and any failure that might have happened. It kind of works like the multiprocessing.AsyncResult class returned by multiprocessing.Pool.map_async.

  • Added dmap() and dmap_async(). This works like the multiprocessing.Pool versions except they are tasks distributed to the celery server. Example:

    >>> from celery.task import dmap
    >>> import operator
    >>> dmap(operator.add, [[2, 2], [4, 4], [8, 8]])
    >>> [4, 8, 16]
    >>> from celery.task import dmap_async
    >>> import operator
    >>> result = dmap_async(operator.add, [[2, 2], [4, 4], [8, 8]])
    >>> result.ready()
    >>> time.sleep(1)
    >>> result.ready()
    >>> result.result
    [4, 8, 16]
  • Refactored the task metadata cache and database backends, and added a new backend for Tokyo Tyrant. You can set the backend in your django settings file. E.g.:

    CELERY_RESULT_BACKEND = "database"; # Uses the database
    CELERY_RESULT_BACKEND = "cache"; # Uses the django cache framework
    CELERY_RESULT_BACKEND = "tyrant"; # Uses Tokyo Tyrant
    TT_HOST = "localhost"; # Hostname for the Tokyo Tyrant server.
    TT_PORT = 6657; # Port of the Tokyo Tyrant server.


release-date:2009-05-12 02:08 P.M CET
  • The logging system was leaking file descriptors, resulting in servers stopping with the EMFILES (too many open files) error. (fixed)


release-date:2009-05-11 12:46 P.M CET
  • Tasks now supports both positional arguments and keyword arguments.
  • Requires carrot 0.3.8.
  • The daemon now tries to reconnect if the connection is lost.


release-date:2009-05-07 12:27 P.M CET
  • Better test coverage
  • More documentation
  • celeryd doesn’t emit Queue is empty message if settings.CELERYD_EMPTY_MSG_EMIT_EVERY is 0.


release-date:2009-04-30 1:50 P.M CET
  • Added some unit tests
  • Can now use the database for task metadata (like if the task has been executed or not). Set settings.CELERY_TASK_META
  • Can now run python test to run the unit tests from within the tests project.
  • Can set the AMQP exchange/routing key/queue using settings.CELERY_AMQP_EXCHANGE, settings.CELERY_AMQP_ROUTING_KEY, and settings.CELERY_AMQP_CONSUMER_QUEUE.


release-date:2009-04-28 2:13 P.M CET
  • Introducing TaskSet. A set of subtasks is executed and you can find out how many, or if all them, are done (excellent for progress bars and such)

  • Now catches all exceptions when running Task.__call__, so the daemon doesn’t die. This doesn’t happen for pure functions yet, only Task classes.

  • autodiscover() now works with zipped eggs.

  • celeryd: Now adds current working directory to sys.path for convenience.

  • The run_every attribute of PeriodicTask classes can now be a datetime.timedelta() object.

  • celeryd: You can now set the DJANGO_PROJECT_DIR variable for celeryd and it will add that to sys.path for easy launching.

  • Can now check if a task has been executed or not via HTTP.

  • You can do this by including the celery into your project,

    >>> url(r'^celery/$', include("celery.urls"))

    then visiting the following url,:


    this will return a JSON dictionary like e.g:

    >>> {"task": {"id": $task_id, "executed": true}}
  • delay_task now returns string id, not uuid.UUID instance.

  • Now has PeriodicTasks, to have cron like functionality.

  • Project changed name from crunchy to celery. The details of the name change request is in docs/name_change_request.txt.


release-date:2009-04-24 11:28 A.M CET
  • Initial release

Previous topic

Platform Specific - celery.platforms

Next topic

Interesting Links

This Page