code: def initialize_plugs(self, plug_types=None):
      
      types = plug_types if plug_types is not None else self._plug_types
      for plug_type in types:
        # Create a logger for this plug. All plug loggers go under the 'plug'
        # sub-logger in the logger hierarchy.
        plug_logger = self.logger.getChild(plug_type.__name__)
        if plug_type in self._plugs_by_type:
          continue
        try:
          if not issubclass(plug_type, BasePlug):
            raise InvalidPlugError(
                'Plug type "%s" is not an instance of BasePlug' % plug_type)
          if plug_type.logger != _LOG:
            # They put a logger attribute on the class itself, overriding ours.
            raise InvalidPlugError(
                'Do not override "logger" in your plugs.', plug_type)
  
          # Override the logger so that __init__'s logging goes into the record.
          plug_type.logger = plug_logger
          try:
            plug_instance = plug_type()
          finally:
            # Now set it back since we'll give the instance a logger in a moment.
            plug_type.logger = _LOG
          # Set the logger attribute directly (rather than in BasePlug) so we
          # don't depend on subclasses' implementation of __init__ to have it
          # set.
          if plug_instance.logger != _LOG:
            raise InvalidPlugError(
                'Do not set "self.logger" in __init__ in your plugs', plug_type)
          else:
            # Now the instance has its own copy of the test logger.
            plug_instance.logger = plug_logger
        except Exception:  # pylint: disable=broad-except
          plug_logger.exception('Exception instantiating plug type %s', plug_type)
          self.tear_down_plugs()
          raise
        self.update_plug(plug_type, plug_instance)
docs: Instantiate required plugs.
  
      Instantiates plug types and saves the instances in self._plugs_by_type for
      use in provide_plugs().
  
      Args:
        plug_types: Plug types may be specified here rather than passed
                    into the constructor (this is used primarily for unit testing
                    phases).