docs: def add_logger(self, name, address, conn_type, log_dir_path=None, **kwargs):
          ''' Add a new stream capturer to the manager.
  
          Add a new stream capturer to the manager with the provided configuration
          details. If an existing capturer is monitoring the same address the
          new handler will be added to it.
  
          Args:
              name:
                  A string defining the new capturer's name.
  
              address:
                  A tuple containing address data for the capturer. Check the
                  :class:`SocketStreamCapturer` documentation for what is
                  required.
  
              conn_type:
                  A string defining the connection type. Check the
                  :class:`SocketStreamCapturer` documentation for a list of valid
                  options.
  
              log_dir_path:
                  An optional path defining the directory where the
                  capturer should write its files. If this isn't provided the root
                  log directory from the manager configuration is used.
  
          '''
          capture_handler_conf = kwargs
  
          if not log_dir_path:
              log_dir_path = self._mngr_conf['root_log_directory']
  
          log_dir_path = os.path.normpath(os.path.expanduser(log_dir_path))
  
          capture_handler_conf['log_dir'] = log_dir_path
          capture_handler_conf['name'] = name
          if 'rotate_log' not in capture_handler_conf:
              capture_handler_conf['rotate_log'] = True
  
          transforms = []
          if 'pre_write_transforms' in capture_handler_conf:
              for transform in capture_handler_conf['pre_write_transforms']:
                  if isinstance(transform, str):
                      if globals().has_key(transform):
                          transforms.append(globals().get(transform))
                      else:
                          msg = (
                              'Unable to load data transformation '
                              '"{}" for handler "{}"'
                          ).format(
                              transform,
                              capture_handler_conf['name']
                          )
                          log.warn(msg)
                  elif hasattr(transform, '__call__'):
                      transforms.append(transform)
                  else:
                      msg = (
                          'Unable to determine how to load data transform "{}"'
                      ).format(transform)
                      log.warn(msg)
          capture_handler_conf['pre_write_transforms'] = transforms
  
          address_key = str(address)
          if address_key in self._stream_capturers:
              capturer = self._stream_capturers[address_key][0]
              capturer.add_handler(capture_handler_conf)
              return
  
          socket_logger = SocketStreamCapturer(capture_handler_conf,
                                               address,
                                               conn_type)
          greenlet = gevent.spawn(socket_logger.socket_monitor_loop)
  
          self._stream_capturers[address_key] = (
              socket_logger,
              greenlet
          )
          self._pool.add(greenlet)