Something like this. Add n into you logging.basicConfig between asctime and levelname

>>> logging.basicConfig(level=logging.DEBUG, format='%(asctime)sn %(levelname)s %(message)s',datefmt='%H:%M:%S') 

Use a custom Formatter which uses different format strings at different times. You can’t do this using basicConfig() – you’ll have to use other parts of the logging API.

class MyFormatter(logging.Formatter):
    def format(self, record):
        # set self._fmt to value with or without newline,
        # as per your decision criteria
        # self._fmt = ...
        return super(MyFormatter, self).format(record)

Or, you can call the super method, then modify the string to insert a newline before returning it (in case it’s dependent on line length, say).

Could you not add the newline after the first hello? i.e.

logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(levelname)s %(message)s', datefmt='%H:%M:%S')
logging.info('hellon')
logging.info('new hello')

Which will output

2014-08-06 11:37:24,061 INFO    : hello

2014-08-06 11:37:24,061 INFO    : new hello

Easiest way to insert newlines that I figured out:

logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(levelname)snr%(message)s', datefmt='%H:%M:%S')
logging.info('hello')
logging.info('new hello')

11:50:32 INFO
hello
11:50:32 INFO
new hello

Following up on Vinay Salip’s helpful answer (below), I did it this way (I’m using the python3 superclass convention, but super(MyFormatter, self) works just as well) …

class MyFormatter(logging.Formatter):
    def format(self, record):
        return super().format(record).replace(r'n', 'n')

Then, I can embed newlines as follows:

logging.info('Message\n\n\n\nOther stuff')

or

logging.info(r'MessagennnnOther stuff')

As an alternative to Hai Vu’s Method 2 you could as well reset the handler’s Formatter every time you want to log a new line:

import logging
import types

def log_newline(self, how_many_lines=1):
    # Switch formatter, output a blank line
    self.handler.setFormatter(self.blank_formatter)

    for i in range(how_many_lines):
        self.info('')

    # Switch back
    self.handler.setFormatter(self.formatter)


def create_logger():
    # Create a handler
    handler = logging.StreamHandler()
    handler.setLevel(logging.DEBUG)
    formatter = logging.Formatter(fmt="%(name)s %(levelname)-8s: %(message)s")        
    blank_formatter = logging.Formatter(fmt="")
    handler.setFormatter(formatter)


    # Create a logger, with the previously-defined handler
    logger = logging.getLogger('logging_test')
    logger.setLevel(logging.DEBUG)
    logger.addHandler(handler)

    # Save some data and add a method to logger object
    logger.handler = handler
    logger.formatter = formatter
    logger.blank_formatter = blank_formatter
    logger.newline = types.MethodType(log_newline, logger)

    return logger

if __name__ == '__main__':
    logger = create_logger()
    logger.info('Start reading database')
    logger.info('Updating records ...')
    logger.newline()
    logger.info('Finish updating records')

Output

logging_test INFO    : Start reading database  
logging_test INFO    : Updating records ...

logging_test INFO    : Finish updating records

The advantage of this is that you have a single handler. For example you can define a FileHandler‘s mode-attribute to write, if you wanted to clean your log-file on every new run of your program.

If you are just looking to output some debug code in development then you may not want to spend time on this. The 5 second fix is this;

str = "nnn"
log.getLogger().debug(str)

where the logger is the standard python logger

If you use FileHandler or descendants thereof, these two functions may help. An added benefit is that all FileHandler type handlers attached to the logger should get the newline.

def getAllLoggerFilenames(logger):
  """ Returns array of all log filenames attached to the logger. """
  logFiles = [];
  parent = logger.__dict__['parent'];
  if parent.__class__.__name__ == 'RootLogger':
    for h in logger.__dict__['handlers']:
      if h.baseFilename:
        logFiles.append(h.baseFilename);
  else:
    logFiles = getAllLoggerFilenames(parent);
  return logFiles;

def logBlankLine(logger):
  """ This utility method writes a blank line to the log. """
  logNames = getAllLoggerFilenames(logger)
  for fn in logNames:
    with open(fn, 'a') as fh:
      fh.write("n")

Usage:

# We use YAML for logging config files, YMMV:
with open(logConfig, 'rt') as f:
  logging.config.dictConfig(yaml.safe_load(f.read()))

logger = logging.getLogger("test.test")

logger.info("line 1")
logBlankLine(logger)
logger.info("line 2")

Output:

2019/12/22 16:33:59.152: INFO    : test.test                 : line 1

2019/12/22 16:33:59.152: INFO    : test.test                 : line 2

The easiest solution is to use f-strings if you are using Python 3:

logging.info( f'hellon' )

What about writing to the log file, without the logging service?

fn_log = 'test.log'
logging.basicConfig(filename=fn_log, level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s', datefmt='%H:%M:%S')
logging.info('hello')
logging.warning('no empty line')

def empty_line(fn_log):
    new_empty_line = open(fn_log,'a+')
    new_empty_line.write('n')
    new_empty_line.close()

empty_line(fn_log)
logging.warning('hello') 

Output:

09:26:00 INFO hello
11:51:05 INFO hello
11:51:05 WARNING no empty line

11:51:05 WARNING hello

You can try the following solution. It’s simple and straightforward.

logging.debug("b" * 20)  # output blank line using escape character
logging.debug("debug message")