code: def log_success_event(
      self, kwargs, response_obj, start_time, end_time
  ):
      try:
          """
          Update latency usage on success
          """
          if kwargs["litellm_params"].get("metadata") is None:
              pass
          else:
              model_group = kwargs["litellm_params"]["metadata"].get(
                  "model_group", None
              )
  
              id = (
                  kwargs["litellm_params"]
                  .get("model_info", {})
                  .get("id", None)
              )
              if model_group is None or id is None:
                  return
  
              # ------------
              # Setup values
              # ------------
              """
                  {
                      {model_group}_map: {
                          id: {
                              "latency": [..]  
                              f"{date:hour:minute}" : {"tpm": 34, "rpm": 3}      
                          }
                      }
                  }
                  """
              latency_key = f"{model_group}_map"
  
              current_date = datetime.now().strftime("%Y-%m-%d")
              current_hour = datetime.now().strftime("%H")
              current_minute = datetime.now().strftime("%M")
              precise_minute = (
                  f"{current_date}-{current_hour}-{current_minute}"
              )
  
              response_ms: timedelta = end_time - start_time
  
              final_value = response_ms
              total_tokens = 0
  
              if isinstance(response_obj, ModelResponse):
                  completion_tokens = (
                      response_obj.usage.completion_tokens
                  )
                  total_tokens = response_obj.usage.total_tokens
                  final_value = float(
                      completion_tokens / response_ms.total_seconds()
                  )
  
              # ------------
              # Update usage
              # ------------
  
              request_count_dict = (
                  self.router_cache.get_cache(key=latency_key) or {}
              )
  
              if id not in request_count_dict:
                  request_count_dict[id] = {}
  
              ## Latency
              request_count_dict[id].setdefault("latency", []).append(
                  final_value
              )
  
              if precise_minute not in request_count_dict[id]:
                  request_count_dict[id][precise_minute] = {}
  
              ## TPM
              request_count_dict[id][precise_minute]["tpm"] = (
                  request_count_dict[id][precise_minute].get("tpm", 0)
                  + total_tokens
              )
  
              ## RPM
              request_count_dict[id][precise_minute]["rpm"] = (
                  request_count_dict[id][precise_minute].get("rpm", 0)
                  + 1
              )
  
              self.router_cache.set_cache(
                  key=latency_key,
                  value=request_count_dict,
                  ttl=self.routing_args.ttl,
              )  # reset map within window
  
              ### TESTING ###
              if self.test_flag:
                  self.logged_success += 1
      except Exception as e:
          traceback.print_exc()
          pass
  
file_path: litellm/litellm/router_strategy/lowest_latency.py
imports: from pydantic import BaseModel, Extra, Field, root_validator
  import dotenv, os, requests, random
  from typing import Optional, Union, List, Dict
  from datetime import datetime, timedelta
  import traceback
  from litellm.caching import DualCache
  from litellm.integrations.custom_logger import CustomLogger
  from litellm import ModelResponse
  from litellm import token_counter
label_desc: Use image node_id 2 for calling the LowestLatencyLoggingHandler obj's underlying member method code with example usage: obj.log_success_event(kwargs, response_obj, start_time, end_time) without return types