code: def _process_tb_event(self, event):
      def create_ndarray(tensor):
          res = tensor_util.make_ndarray(tensor)
          if res.dtype == "object":
              return None
          else:
              return res
  
      step = event.step
      fail_count = 0
      _err_info = None
  
      for value in event.summary.value:
          tag = value.tag
          plugin_name = value.metadata.plugin_data.plugin_name
          if (
              len(plugin_name) > 0
              and plugin_name not in self.supported_plugins
          ):
              if not self.unsupported_plugin_noticed:
                  logging.warning(
                      "Found unsupported plugin type({}) in the log file. "
                      "Data for these wont be processed. "
                      "Supported plugin types are: {}".format(
                          plugin_name, ", ".join(self.supported_plugins)
                      ),
                  )
                  self.unsupported_plugin_noticed = True
              continue
          track_val = None
          try:
              if value.HasField("tensor"):
                  # TODO: [MV] check the case when audios are passed via tensor
                  if plugin_name == "images":
                      tensor = value.tensor.string_val[2:]
                      track_val = [
                          Image(tf.image.decode_image(t).numpy())
                          for t in tensor
                      ]
                      if len(track_val) == 1:
                          track_val = track_val[0]
                  elif plugin_name == "histograms":
                      track_val = _decode_histogram_from_plugin(value)
                  elif plugin_name == "scalars" or plugin_name == "":
                      track_val = create_ndarray(value.tensor)
                  else:
                      track_val = value.tensor.float_val[0]
              elif value.HasField("simple_value"):
                  track_val = value.simple_value
              elif value.HasField("image"):
                  track_val = Image(
                      tf.image.decode_image(
                          value.image.encoded_image_string
                      ).numpy()
                  )
              elif value.HasField("audio"):
                  tf_audio, sample_rate = tf.audio.decode_wav(
                      value.audio.encoded_audio_string
                  )
                  track_val = Audio(tf_audio.numpy(), rate=sample_rate)
              elif value.HasField("histo"):
                  track_val = _decode_histogram(value)
  
          except RuntimeError as exc:
              # catch all the nasty failures
              fail_count += 1
              if not _err_info:
                  _err_info = str(exc)
              continue
  
          if track_val is not None:
              self.queue.put(
                  TensorboardEvent(
                      track_val,
                      tag,
                      step,
                      context={"entry": self.folder_name},
                  )
              )
      if fail_count:
          logging.warning(
              f"Failed to process {fail_count} entries. First exception: {_err_info}"
          )
  
imports: from tensorboard.backend.event_processing.directory_watcher import DirectoryWatcher
  from tensorboard.backend.event_processing import event_file_loader
  import tensorflow
  from tensorboard.util import tensor_util
  import time
  import threading
  from pathlib import Path
  import logging
  import os
  import weakref
  import queue
  from typing import Any
  from aim import Audio, Image, Distribution
label_desc: Use image node_id 5 for calling the TensorboardFolderTracker obj's underlying member method code with example usage: obj._process_tb_event(event) and returns: None, res