code: def test_chat_completion(client):
      try:
          # Your test data
          litellm.set_verbose = False
          from litellm.proxy.utils import get_instance_fn
  
          my_custom_logger = get_instance_fn(
              value="custom_callbacks.my_custom_logger",
              config_file_path=python_file_path,
          )
  
          print("id of initialized custom logger", id(my_custom_logger))
  
          litellm.callbacks = [my_custom_logger]
          # import the initialized custom logger
          print(litellm.callbacks)
  
          # assert len(litellm.callbacks) == 1 # assert litellm is initialized with 1 callback
  
          print("LiteLLM Callbacks", litellm.callbacks)
          print("my_custom_logger", my_custom_logger)
          assert my_custom_logger.async_success == False
  
          test_data = {
              "model": "Azure OpenAI GPT-4 Canada",
              "messages": [
                  {"role": "user", "content": "write a litellm poem"},
              ],
              "max_tokens": 10,
          }
  
          response = client.post(
              "/chat/completions", json=test_data, headers=headers
          )
          print("made request", response.status_code, response.text)
          print("LiteLLM Callbacks", litellm.callbacks)
          asyncio.sleep(1)  # sleep while waiting for callback to run
  
          print(
              "my_custom_logger in /chat/completions",
              my_custom_logger,
              "id",
              id(my_custom_logger),
          )
          print("vars my custom logger, ", vars(my_custom_logger))
          assert (
              my_custom_logger.async_success == True
          )  # checks if the status of async_success is True, only the async_log_success_event can set this to true
          assert (
              my_custom_logger.async_completion_kwargs["model"]
              == "chatgpt-v-2"
          )  # checks if kwargs passed to async_log_success_event are correct
          print(
              "\n\n Custom Logger Async Completion args",
              my_custom_logger.async_completion_kwargs,
          )
          litellm_params = my_custom_logger.async_completion_kwargs.get(
              "litellm_params"
          )
          metadata = litellm_params.get("metadata", None)
          print(
              "\n\n Metadata in custom logger kwargs",
              litellm_params.get("metadata"),
          )
          assert metadata is not None
          assert "user_api_key" in metadata
          assert "headers" in metadata
          config_model_info = litellm_params.get("model_info")
          proxy_server_request_object = litellm_params.get(
              "proxy_server_request"
          )
  
          assert config_model_info == {
              "id": "gm",
              "input_cost_per_token": 0.0002,
              "mode": "chat",
          }
          assert proxy_server_request_object == {
              "url": "http://testserver/chat/completions",
              "method": "POST",
              "headers": {
                  "host": "testserver",
                  "accept": "*/*",
                  "accept-encoding": "gzip, deflate",
                  "connection": "keep-alive",
                  "user-agent": "testclient",
                  "authorization": "Bearer sk-1234",
                  "content-length": "123",
                  "content-type": "application/json",
              },
              "body": {
                  "model": "Azure OpenAI GPT-4 Canada",
                  "messages": [
                      {
                          "role": "user",
                          "content": "write a litellm poem",
                      }
                  ],
                  "max_tokens": 10,
              },
          }
          result = response.json()
          print(f"Received response: {result}")
          print("\nPassed /chat/completions with Custom Logger!")
      except Exception as e:
          pytest.fail(f"LiteLLM Proxy test failed. Exception {str(e)}")
  
file_path: litellm/litellm/tests/test_proxy_custom_logger.py
imports: import sys, os
  import traceback
  from dotenv import load_dotenv
  import os, io, asyncio
  import pytest
  import litellm
  from litellm import embedding, completion, completion_cost, Timeout
  from litellm import RateLimitError
  import importlib, inspect
  from fastapi.testclient import TestClient
  from fastapi import FastAPI
  from litellm.proxy.proxy_server import router, save_worker_config, initialize, startup_event
label_desc: Use image node_id 3 for calling a global function with example usage: test_chat_completion(client) without return types