Two approaches to Logging when Unit Testing with Python











up vote
-1
down vote

favorite












What the relative merits of these two approaches to Logging when Unit Testing with Python. Is one approach superior or does each approach suit specific circumstances. How might each approach be improved.



#!/usr/bin/env python
import logging
import unittest

class LoggingTest(unittest.TestCase):

logging.basicConfig(level=logging.INFO)

def setUp(self):
pass

def test_logger(self):
logging.info("logging.info test_logger")
pass


Getting a logger by name



#!/usr/bin/env python
import logging
import unittest

class GetLoggerTest(unittest.TestCase):
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)

def setUp(self):
pass

def test_logger(self):
self.logger.info("self.logger.info test_logger")
pass









share|improve this question


























    up vote
    -1
    down vote

    favorite












    What the relative merits of these two approaches to Logging when Unit Testing with Python. Is one approach superior or does each approach suit specific circumstances. How might each approach be improved.



    #!/usr/bin/env python
    import logging
    import unittest

    class LoggingTest(unittest.TestCase):

    logging.basicConfig(level=logging.INFO)

    def setUp(self):
    pass

    def test_logger(self):
    logging.info("logging.info test_logger")
    pass


    Getting a logger by name



    #!/usr/bin/env python
    import logging
    import unittest

    class GetLoggerTest(unittest.TestCase):
    logger = logging.getLogger(__name__)
    logger.setLevel(logging.INFO)

    def setUp(self):
    pass

    def test_logger(self):
    self.logger.info("self.logger.info test_logger")
    pass









    share|improve this question
























      up vote
      -1
      down vote

      favorite









      up vote
      -1
      down vote

      favorite











      What the relative merits of these two approaches to Logging when Unit Testing with Python. Is one approach superior or does each approach suit specific circumstances. How might each approach be improved.



      #!/usr/bin/env python
      import logging
      import unittest

      class LoggingTest(unittest.TestCase):

      logging.basicConfig(level=logging.INFO)

      def setUp(self):
      pass

      def test_logger(self):
      logging.info("logging.info test_logger")
      pass


      Getting a logger by name



      #!/usr/bin/env python
      import logging
      import unittest

      class GetLoggerTest(unittest.TestCase):
      logger = logging.getLogger(__name__)
      logger.setLevel(logging.INFO)

      def setUp(self):
      pass

      def test_logger(self):
      self.logger.info("self.logger.info test_logger")
      pass









      share|improve this question













      What the relative merits of these two approaches to Logging when Unit Testing with Python. Is one approach superior or does each approach suit specific circumstances. How might each approach be improved.



      #!/usr/bin/env python
      import logging
      import unittest

      class LoggingTest(unittest.TestCase):

      logging.basicConfig(level=logging.INFO)

      def setUp(self):
      pass

      def test_logger(self):
      logging.info("logging.info test_logger")
      pass


      Getting a logger by name



      #!/usr/bin/env python
      import logging
      import unittest

      class GetLoggerTest(unittest.TestCase):
      logger = logging.getLogger(__name__)
      logger.setLevel(logging.INFO)

      def setUp(self):
      pass

      def test_logger(self):
      self.logger.info("self.logger.info test_logger")
      pass






      python unit-testing logging






      share|improve this question













      share|improve this question











      share|improve this question




      share|improve this question










      asked 9 hours ago









      Martin Spamer

      24329




      24329






















          1 Answer
          1






          active

          oldest

          votes

















          up vote
          0
          down vote













          According to the logging docs:




          The logger name hierarchy is analogous to the Python package hierarchy, and identical to it if you organise your loggers on a per-module basis using the recommended construction logging.getLogger(name). That’s because in a module, name is the module’s name in the Python package namespace.




          Based on my experience, I would say that you should always use logging.getLogger(name) for bigger projects, as it'll make logging modularization easier.



          As your question is broad, I recommend you to read the Logging Cookbook, in this link, as it holds many important use cases in which you could optimize the way you use logging.



          It's also possible to mix both cases in order to add a timestamp, in example, which is an improved way of using this module:



          #!/usr/bin/env python
          import logging
          import unittest

          class GetLoggerTest(unittest.TestCase):
          logger = logging.getLogger(__name__)
          logging.basicConfig(format = '%(asctime)s %(module)s %(levelname)s: %(message)s',
          datefmt = '%m/%d/%Y %I:%M:%S %p', level = logging.INFO)

          def setUp(self):
          pass

          def test_logger(self):
          self.logger.info("self.logger.info test_logger")
          pass





          share|improve this answer





















            Your Answer





            StackExchange.ifUsing("editor", function () {
            return StackExchange.using("mathjaxEditing", function () {
            StackExchange.MarkdownEditor.creationCallbacks.add(function (editor, postfix) {
            StackExchange.mathjaxEditing.prepareWmdForMathJax(editor, postfix, [["\$", "\$"]]);
            });
            });
            }, "mathjax-editing");

            StackExchange.ifUsing("editor", function () {
            StackExchange.using("externalEditor", function () {
            StackExchange.using("snippets", function () {
            StackExchange.snippets.init();
            });
            });
            }, "code-snippets");

            StackExchange.ready(function() {
            var channelOptions = {
            tags: "".split(" "),
            id: "196"
            };
            initTagRenderer("".split(" "), "".split(" "), channelOptions);

            StackExchange.using("externalEditor", function() {
            // Have to fire editor after snippets, if snippets enabled
            if (StackExchange.settings.snippets.snippetsEnabled) {
            StackExchange.using("snippets", function() {
            createEditor();
            });
            }
            else {
            createEditor();
            }
            });

            function createEditor() {
            StackExchange.prepareEditor({
            heartbeatType: 'answer',
            convertImagesToLinks: false,
            noModals: true,
            showLowRepImageUploadWarning: true,
            reputationToPostImages: null,
            bindNavPrevention: true,
            postfix: "",
            imageUploader: {
            brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
            contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
            allowUrls: true
            },
            onDemand: true,
            discardSelector: ".discard-answer"
            ,immediatelyShowMarkdownHelp:true
            });


            }
            });














             

            draft saved


            draft discarded


















            StackExchange.ready(
            function () {
            StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodereview.stackexchange.com%2fquestions%2f208251%2ftwo-approaches-to-logging-when-unit-testing-with-python%23new-answer', 'question_page');
            }
            );

            Post as a guest















            Required, but never shown

























            1 Answer
            1






            active

            oldest

            votes








            1 Answer
            1






            active

            oldest

            votes









            active

            oldest

            votes






            active

            oldest

            votes








            up vote
            0
            down vote













            According to the logging docs:




            The logger name hierarchy is analogous to the Python package hierarchy, and identical to it if you organise your loggers on a per-module basis using the recommended construction logging.getLogger(name). That’s because in a module, name is the module’s name in the Python package namespace.




            Based on my experience, I would say that you should always use logging.getLogger(name) for bigger projects, as it'll make logging modularization easier.



            As your question is broad, I recommend you to read the Logging Cookbook, in this link, as it holds many important use cases in which you could optimize the way you use logging.



            It's also possible to mix both cases in order to add a timestamp, in example, which is an improved way of using this module:



            #!/usr/bin/env python
            import logging
            import unittest

            class GetLoggerTest(unittest.TestCase):
            logger = logging.getLogger(__name__)
            logging.basicConfig(format = '%(asctime)s %(module)s %(levelname)s: %(message)s',
            datefmt = '%m/%d/%Y %I:%M:%S %p', level = logging.INFO)

            def setUp(self):
            pass

            def test_logger(self):
            self.logger.info("self.logger.info test_logger")
            pass





            share|improve this answer

























              up vote
              0
              down vote













              According to the logging docs:




              The logger name hierarchy is analogous to the Python package hierarchy, and identical to it if you organise your loggers on a per-module basis using the recommended construction logging.getLogger(name). That’s because in a module, name is the module’s name in the Python package namespace.




              Based on my experience, I would say that you should always use logging.getLogger(name) for bigger projects, as it'll make logging modularization easier.



              As your question is broad, I recommend you to read the Logging Cookbook, in this link, as it holds many important use cases in which you could optimize the way you use logging.



              It's also possible to mix both cases in order to add a timestamp, in example, which is an improved way of using this module:



              #!/usr/bin/env python
              import logging
              import unittest

              class GetLoggerTest(unittest.TestCase):
              logger = logging.getLogger(__name__)
              logging.basicConfig(format = '%(asctime)s %(module)s %(levelname)s: %(message)s',
              datefmt = '%m/%d/%Y %I:%M:%S %p', level = logging.INFO)

              def setUp(self):
              pass

              def test_logger(self):
              self.logger.info("self.logger.info test_logger")
              pass





              share|improve this answer























                up vote
                0
                down vote










                up vote
                0
                down vote









                According to the logging docs:




                The logger name hierarchy is analogous to the Python package hierarchy, and identical to it if you organise your loggers on a per-module basis using the recommended construction logging.getLogger(name). That’s because in a module, name is the module’s name in the Python package namespace.




                Based on my experience, I would say that you should always use logging.getLogger(name) for bigger projects, as it'll make logging modularization easier.



                As your question is broad, I recommend you to read the Logging Cookbook, in this link, as it holds many important use cases in which you could optimize the way you use logging.



                It's also possible to mix both cases in order to add a timestamp, in example, which is an improved way of using this module:



                #!/usr/bin/env python
                import logging
                import unittest

                class GetLoggerTest(unittest.TestCase):
                logger = logging.getLogger(__name__)
                logging.basicConfig(format = '%(asctime)s %(module)s %(levelname)s: %(message)s',
                datefmt = '%m/%d/%Y %I:%M:%S %p', level = logging.INFO)

                def setUp(self):
                pass

                def test_logger(self):
                self.logger.info("self.logger.info test_logger")
                pass





                share|improve this answer












                According to the logging docs:




                The logger name hierarchy is analogous to the Python package hierarchy, and identical to it if you organise your loggers on a per-module basis using the recommended construction logging.getLogger(name). That’s because in a module, name is the module’s name in the Python package namespace.




                Based on my experience, I would say that you should always use logging.getLogger(name) for bigger projects, as it'll make logging modularization easier.



                As your question is broad, I recommend you to read the Logging Cookbook, in this link, as it holds many important use cases in which you could optimize the way you use logging.



                It's also possible to mix both cases in order to add a timestamp, in example, which is an improved way of using this module:



                #!/usr/bin/env python
                import logging
                import unittest

                class GetLoggerTest(unittest.TestCase):
                logger = logging.getLogger(__name__)
                logging.basicConfig(format = '%(asctime)s %(module)s %(levelname)s: %(message)s',
                datefmt = '%m/%d/%Y %I:%M:%S %p', level = logging.INFO)

                def setUp(self):
                pass

                def test_logger(self):
                self.logger.info("self.logger.info test_logger")
                pass






                share|improve this answer












                share|improve this answer



                share|improve this answer










                answered 5 hours ago









                Neves4

                85




                85






























                     

                    draft saved


                    draft discarded



















































                     


                    draft saved


                    draft discarded














                    StackExchange.ready(
                    function () {
                    StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodereview.stackexchange.com%2fquestions%2f208251%2ftwo-approaches-to-logging-when-unit-testing-with-python%23new-answer', 'question_page');
                    }
                    );

                    Post as a guest















                    Required, but never shown





















































                    Required, but never shown














                    Required, but never shown












                    Required, but never shown







                    Required, but never shown

































                    Required, but never shown














                    Required, but never shown












                    Required, but never shown







                    Required, but never shown







                    Popular posts from this blog

                    Create new schema in PostgreSQL using DBeaver

                    Deepest pit of an array with Javascript: test on Codility

                    Costa Masnaga