docs: def _get_tags(self, entity=None, tag_type=None):
          """Generate the tags for a given entity (container or image) according to a list of tag names."""
          # Start with custom tags
          tags = list(self.custom_tags)
  
          # Collect pod names as tags on kubernetes
          if Platform.is_k8s() and KubeUtil.POD_NAME_LABEL not in self.collect_labels_as_tags:
              self.collect_labels_as_tags.append(KubeUtil.POD_NAME_LABEL)
              self.collect_labels_as_tags.append(KubeUtil.CONTAINER_NAME_LABEL)
  
          # Collect container names as tags on rancher
          if Platform.is_rancher():
              if RANCHER_CONTAINER_NAME not in self.collect_labels_as_tags:
                  self.collect_labels_as_tags.append(RANCHER_CONTAINER_NAME)
              if RANCHER_SVC_NAME not in self.collect_labels_as_tags:
                  self.collect_labels_as_tags.append(RANCHER_SVC_NAME)
              if RANCHER_STACK_NAME not in self.collect_labels_as_tags:
                  self.collect_labels_as_tags.append(RANCHER_STACK_NAME)
  
          if entity is not None:
              pod_name = None
              namespace = None
              # Get labels as tags
              labels = entity.get("Labels")
              if labels is not None:
                  for k in self.collect_labels_as_tags:
                      if k in labels:
                          v = labels[k]
                          if k == KubeUtil.POD_NAME_LABEL and Platform.is_k8s():
                              pod_name = v
                              k = "pod_name"
                              if "-" in pod_name:
                                  replication_controller = "-".join(pod_name.split("-")[:-1])
                                  if "/" in replication_controller:  # k8s <= 1.1
                                      namespace, replication_controller = replication_controller.split("/", 1)
  
                                  elif KubeUtil.NAMESPACE_LABEL in labels:  # k8s >= 1.2
                                      namespace = labels[KubeUtil.NAMESPACE_LABEL]
  
                                  tags.append("kube_namespace:%s" % namespace)
                                  tags.append("kube_replication_controller:%s" % replication_controller)
                                  tags.append("pod_name:%s" % pod_name)
  
                          elif k == KubeUtil.CONTAINER_NAME_LABEL and Platform.is_k8s():
                              if v:
                                  tags.append("kube_container_name:%s" % v)
                          elif k == SWARM_SVC_LABEL and Platform.is_swarm():
                              if v:
                                  tags.append("swarm_service:%s" % v)
                          elif k == RANCHER_CONTAINER_NAME and Platform.is_rancher():
                              if v:
                                  tags.append('rancher_container:%s' % v)
                          elif k == RANCHER_SVC_NAME and Platform.is_rancher():
                              if v:
                                  tags.append('rancher_service:%s' % v)
                          elif k == RANCHER_STACK_NAME and Platform.is_rancher():
                              if v:
                                  tags.append('rancher_stack:%s' % v)
  
                          elif not v:
                              tags.append(k)
  
                          else:
                              tags.append("%s:%s" % (k, v))
  
                      if k == KubeUtil.POD_NAME_LABEL and Platform.is_k8s() and k not in labels:
                          tags.append("pod_name:no_pod")
  
              # Get entity specific tags
              if tag_type is not None:
                  tag_names = self.tag_names[tag_type]
                  for tag_name in tag_names:
                      tag_value = self._extract_tag_value(entity, tag_name)
                      if tag_value is not None:
                          for t in tag_value:
                              tags.append('%s:%s' % (tag_name, str(t).strip()))
  
              # Add kube labels and creator/service tags
              if Platform.is_k8s() and namespace and pod_name:
                  kube_tags = self.kube_pod_tags.get("{0}/{1}".format(namespace, pod_name))
                  if kube_tags:
                      tags.extend(list(kube_tags))
  
              if self.metadata_collector.has_detected():
                  orch_tags = self.metadata_collector.get_container_tags(co=entity)
                  tags.extend(orch_tags)
  
          return tags