Removes Task.logger (not in 2.5)

celery/app/defaults.py

@@ -57,6 +57,9 @@ class Option(object):
     def to_python(self, value):
         return self.typemap[self.type](value)
 
+    def __repr__(self):
+        return '<Option: type->%s default->%r>' % (self.type, self.default)
+
 
 NAMESPACES = {
     'BROKER': {

celery/app/task.py

@@ -24,7 +24,6 @@ from celery.result import EagerResult
 from celery.utils import fun_takes_kwargs, uuid, maybe_reraise
 from celery.utils.functional import mattrgetter, maybe_list
 from celery.utils.imports import instantiate
-from celery.utils.log import get_task_logger
 from celery.utils.mail import ErrorMail
 
 from .annotations import resolve_all as resolve_all_annotations
@@ -798,13 +797,9 @@ class Task(object):
         """`repr(task)`"""
         return '<@task: %s>' % (self.name, )
 
-    def _get_logger(self, **kwargs):
-        """Get task-aware logger object."""
-        return get_task_logger(self.name)
-    logger = cached_property(_get_logger)
-
     @property
     def request(self):
+        """Current request object."""
         return self.request_stack.top
 
     @property

celery/app/utils.py

@@ -18,8 +18,7 @@ from celery.utils.imports import qualname
 
 from .defaults import find
 
-SETTINGS_INFO = '%s %s'
-
+#: Format used to generate bugreport information.
 BUGREPORT_INFO = """
 software -> celery:%(celery_v)s kombu:%(kombu_v)s py:%(py_v)s
             billiard:%(billiard_v)s %(driver_v)s
@@ -32,16 +31,14 @@ settings -> transport:%(transport)s results:%(results)s
 
 
 class Settings(datastructures.ConfigurationView):
+    """Celery settings object."""
 
     @property
     def CELERY_RESULT_BACKEND(self):
-        """Resolves deprecated alias ``CELERY_BACKEND``."""
         return self.first('CELERY_RESULT_BACKEND', 'CELERY_BACKEND')
 
     @property
     def BROKER_TRANSPORT(self):
-        """Resolves compat aliases :setting:`BROKER_BACKEND`
-        and :setting:`CARROT_BACKEND`."""
         return self.first('BROKER_TRANSPORT',
                           'BROKER_BACKEND', 'CARROT_BACKEND')
 
@@ -56,21 +53,45 @@ class Settings(datastructures.ConfigurationView):
                 self.first('BROKER_URL', 'BROKER_HOST'))
 
     def without_defaults(self):
+        """Returns the current configuration, but without defaults."""
         # the last stash is the default settings, so just skip that
         return Settings({}, self._order[:-1])
 
-    def find_value_for_key(self, name, namespace='celery'):
-        return self.get_by_parts(*self.find_option(name, namespace)[:-1])
-
     def find_option(self, name, namespace='celery'):
+        """Search for option by name.
+
+        Will return ``(namespace, option_name, Option)`` tuple, e.g.::
+
+            >>> celery.conf.find_option('disable_rate_limits')
+            ('CELERY', 'DISABLE_RATE_LIMITS',
+             <Option: type->bool default->False>))
+
+        :param name: Name of option, cannot be partial.
+        :keyword namespace: Preferred namespace (``CELERY`` by default).
+
+        """
         return find(name, namespace)
 
+    def find_value_for_key(self, name, namespace='celery'):
+        """Shortcut to ``get_by_parts(*find_option(name)[:-1])``"""
+        return self.get_by_parts(*self.find_option(name, namespace)[:-1])
+
     def get_by_parts(self, *parts):
+        """Returns the current value for setting specified as a path.
+
+        Example::
+
+            >>> celery.conf.get_by_parts('CELERY', 'DISABLE_RATE_LIMITS')
+            False
+
+        """
         return self['_'.join(filter(None, parts))]
 
     def humanize(self):
-        return '\n'.join(SETTINGS_INFO % (key + ':', pretty(value, width=50))
-                    for key, value in self.without_defaults().iteritems())
+        """Returns a human readable string showing changes to the
+        configuration."""
+        return '\n'.join('%s %s' % (key + ':', pretty(value, width=50))
+                        for key, value in self.without_defaults().iteritems())
 
 
 class AppPickler(object):
@@ -104,6 +125,7 @@ def _unpickle_app(cls, pickler, *args):
 
 
 def bugreport(app):
+    """Returns a string containing information useful in bug reports."""
     import billiard
     import celery
     import kombu

celery/contrib/abortable.py

@@ -29,11 +29,13 @@ In the consumer:
 .. code-block:: python
 
    from celery.contrib.abortable import AbortableTask
+   from celery.utils.log import get_task_logger
+
+   logger = get_logger(__name__)
 
    class MyLongRunningTask(AbortableTask):
 
        def run(self, **kwargs):
-           logger = self.get_logger(**kwargs)
            results = []
            for x in xrange(100):
                # Check after every 5 loops..

celery/contrib/batches.py

@@ -81,7 +81,7 @@ def apply_batches_task(task, args, loglevel, logfile):
         result = task(*args)
     except Exception, exc:
         result = None
-        task.logger.error('Error: %r', exc, exc_info=True)
+        logger.error('Error: %r', exc, exc_info=True)
     finally:
         task.pop_request()
     return result

celery/task/base.py

@@ -17,6 +17,7 @@ from celery import current_app
 from celery.__compat__ import class_property, reclassmethod
 from celery.app.task import Context, TaskType, Task as BaseTask  # noqa
 from celery.schedules import maybe_schedule
+from celery.utils.log import get_task_logger
 
 #: list of methods that must be classmethods in the old API.
 _COMPAT_CLASSMETHODS = (
@@ -66,8 +67,9 @@ class Task(BaseTask):
         return self.request_stack.top
     request = class_property(_get_request)
 
-    #: Deprecated alias to :attr:`logger``.
-    get_logger = reclassmethod(BaseTask._get_logger)
+    @classmethod
+    def get_logger(self, **kwargs):
+        return get_task_logger(self.name)
 
     @classmethod
     def establish_connection(self, connect_timeout=None):

celery/task/http.py

@@ -20,9 +20,11 @@ except ImportError:  # pragma: no cover
     from cgi import parse_qsl  # noqa
 
 from celery import __version__ as celery_version
+from celery.utils.log import get_task_logger
 from .base import Task as BaseTask
 
 GET_METHODS = frozenset(['GET', 'HEAD'])
+logger = get_task_logger(__name__)
 
 
 class InvalidResponseError(Exception):
@@ -128,11 +130,11 @@ class HttpDispatch(object):
     user_agent = 'celery/%s' % celery_version
     timeout = 5
 
-    def __init__(self, url, method, task_kwargs, logger=None):
+    def __init__(self, url, method, task_kwargs, **kwargs):
         self.url = url
         self.method = method
         self.task_kwargs = task_kwargs
-        self.logger = logger
+        self.logger = kwargs.get("logger") or logger
 
     def make_request(self, url, method, params):
         """Makes an HTTP request and returns the response."""
@@ -188,7 +190,7 @@ class HttpDispatchTask(BaseTask):
     def run(self, url=None, method='GET', **kwargs):
         url = url or self.url
         method = method or self.method
-        return HttpDispatch(url, method, kwargs, self.logger).dispatch()
+        return HttpDispatch(url, method, kwargs).dispatch()
 
 
 class URL(MutableURL):

celery/tests/app/test_log.py

@@ -17,6 +17,7 @@ from celery.utils.log import (
     get_logger,
     ColorFormatter,
     logger as base_logger,
+    get_task_logger,
 )
 from celery.tests.utils import (
     AppCase, Case, override_stdouts, wrap_logger, get_handlers,
@@ -242,7 +243,7 @@ class test_task_logger(test_default_logger):
         @current_app.task
         def test_task():
             pass
-        test_task.logger.handlers = []
+        self.get_logger().handlers = []
         self.task = test_task
         from celery.state import _task_stack
         _task_stack.push(test_task)
@@ -255,7 +256,7 @@ class test_task_logger(test_default_logger):
         return log.setup_task_loggers(*args, **kwargs)
 
     def get_logger(self, *args, **kwargs):
-        return self.task.logger
+        return get_task_logger("test_task_logger")
 
 
 class MockLogger(logging.Logger):

celery/tests/tasks/test_http.py

@@ -100,55 +100,43 @@ class test_MutableURL(Case):
 class test_HttpDispatch(Case):
 
     def test_dispatch_success(self):
-        logger = logging.getLogger('celery.unittest')
-
         with mock_urlopen(success_response(100)):
             d = http.HttpDispatch('http://example.com/mul', 'GET', {
-                                    'x': 10, 'y': 10}, logger)
+                                    'x': 10, 'y': 10})
             self.assertEqual(d.dispatch(), 100)
 
     def test_dispatch_failure(self):
-        logger = logging.getLogger('celery.unittest')
-
         with mock_urlopen(fail_response('Invalid moon alignment')):
             d = http.HttpDispatch('http://example.com/mul', 'GET', {
-                                    'x': 10, 'y': 10}, logger)
+                                    'x': 10, 'y': 10})
             with self.assertRaises(http.RemoteExecuteError):
                 d.dispatch()
 
     def test_dispatch_empty_response(self):
-        logger = logging.getLogger('celery.unittest')
-
         with mock_urlopen(_response('')):
             d = http.HttpDispatch('http://example.com/mul', 'GET', {
-                                    'x': 10, 'y': 10}, logger)
+                                    'x': 10, 'y': 10})
             with self.assertRaises(http.InvalidResponseError):
                 d.dispatch()
 
     def test_dispatch_non_json(self):
-        logger = logging.getLogger('celery.unittest')
-
         with mock_urlopen(_response("{'#{:'''")):
             d = http.HttpDispatch('http://example.com/mul', 'GET', {
-                                    'x': 10, 'y': 10}, logger)
+                                    'x': 10, 'y': 10})
             with self.assertRaises(http.InvalidResponseError):
                 d.dispatch()
 
     def test_dispatch_unknown_status(self):
-        logger = logging.getLogger('celery.unittest')
-
         with mock_urlopen(unknown_response()):
             d = http.HttpDispatch('http://example.com/mul', 'GET', {
-                                    'x': 10, 'y': 10}, logger)
+                                    'x': 10, 'y': 10})
             with self.assertRaises(http.UnknownStatusError):
                 d.dispatch()
 
     def test_dispatch_POST(self):
-        logger = logging.getLogger('celery.unittest')
-
         with mock_urlopen(success_response(100)):
             d = http.HttpDispatch('http://example.com/mul', 'POST', {
-                                    'x': 10, 'y': 10}, logger)
+                                    'x': 10, 'y': 10})
             self.assertEqual(d.dispatch(), 100)