How to check response time with Azure Functions

I am using a program that sends HTTP requests and parameters to Azure Functions’ Durable functions for processing.

I would like to check the time taken for processing and response time in this program, and I would like to check it in the log of Application Insights, but I don’t know how to check it.

How can I find out the response time for each request from the Application Insights logs?

Or, if there is another way to find out the response time for each request other than Application Insights, please let me know.

import azure.functions as func
import azure.durable_functions as df
import logging
import numpy as np
import pandas as pd
import time
import sys

app = df.DFApp(http_auth_level=func.AuthLevel.ANONYMOUS)
@app.route(route="orchestrators/client_function")
@app.durable_client_input(client_name="client")
async def client_function(req: func.HttpRequest, client: df.DurableOrchestrationClient) -> func.HttpResponse:
        activity = int(req.params.get('activity') or req.get_json().get('activity'))
        size = int(req.params.get('size') or req.get_json().get('size'))

    instance_id = await client.start_new("orchestrator", None, {"activity": activity, "size": size})
    logging.info(f"Started orchestration with ID = '{instance_id}'.")
    await client.wait_for_completion_or_create_check_status_response(req, instance_id)
    status = await client.get_status(instance_id)
    return f"runtime: {status.runtime_status}\n\noutput: {status.output}" 


@app.orchestration_trigger(context_name="context")
def orchestrator(context: df.DurableOrchestrationContext) -> dict:
    parameter = context.get_input()
    activity = int(parameter.get("activity"))
    size = int(parameter.get("size"))
    data_size_list, byte_list, time_list = [], [], []
    
    if activity == 1: #DataFrame
        for i in range(2):        
            result  =  yield context.call_activity("activity1", size)
            data_frame = pd.DataFrame.from_dict(result["data"])  # deserialize
            transfer_time  =  time.perf_counter() - result["start"] # Transfer time record when deserialization is finished
            dict_size = sys.getsizeof(result["data"]) # After measuring the transfer time, measure the data size
            dict_size += sum(map(sys.getsizeof, result["data"].values())) + sum(map(sys.getsizeof, result["data"].keys()))

            data_size_list.append(size)
            byte_list.append(dict_size)
            time_list.append(transfer_time)

    output = {"data-size": data_size_list, "data-byte": byte_list, "transfer-time": time_list}
    result = yield context.call_activity("write_csv", output)
    return output

# Transfer DataFrame as dictionary type
@app.activity_trigger(input_name="size")
def  activity1(size: int) -> dict:
    data = np.random.rand(size) # Create a Numpy array with one row and one column of size
    data  =  pd.DataFrame(data) # Convert Numpy array to Dataframe
    start = time.perf_counter() # The time to convert a Dataframe to a serializable dictionary type is also measured, so it is indicated here.
    data_ = data.to_dict() # Convert to serializable type
    return {"data": data_, "start": start}

# Function to write to csv
@app.blob_output(arg_name="outputblob", path="newblob/result.csv", connection="BlobStorageConnection")
@app.activity_trigger(input_name="output")
def  write_csv(output: dict, outputblob: func.Out[str]):
    df = pd.DataFrame(output)
    csv_data = df.to_csv(index=False)
    outputblob.set(csv_data)
    return "Insersed"