Assume the following code:
modify the code in order to calculate the average queuing delay during the simulation. (as a parameter of Measure class)
import simpy
import random
import matplotlib.pyplot as plt

# Parameters
num_edge_nodes = 1
edge_buffer_size = 15
cloud_buffer_size = 20


# service times
cloud_server_time = 10
A_edge_service_time = 4
A_cloud_service_time = 2
B_edge_sevice_time = 2
B_cloud_service_partialprocess = 4
B_cloud_service_fullprocess = 5
propagation_delay = 1


arrival_rate = .8


# Measurements

class Measure:
    def __init__(self, N_arr_a, N_arr_b, drop):
        self.N_arr_A = N_arr_a
        self.N_arr_B = N_arr_b
        self.drop = drop

measurements = Measure(0, 0, 0)


def packet_arrivals(env, micro_data_center, cloud_data_center, data, edge_buffer, cloud_buffer):
    packet_type_options = ['A', 'B']
    packet_id = 1

    while True:
        packet_type = random.choices(packet_type_options, weights=(1 - f, f))[0]

        # Updating arrival data
        if packet_type == "A":
            data.N_arr_A = data.N_arr_A + 1
        else:
            data.N_arr_B = data.N_arr_B + 1



        if len(micro_data_center.items) < edge_buffer:
            if packet_type == "A":
                micro_data_center.put((packet_id, packet_type, A_edge_service_time))
            elif packet_type == "B":
                micro_data_center.put((packet_id, packet_type, B_edge_sevice_time))


        else:
            if len(cloud_data_center.items) < cloud_buffer:
                if packet_type == "A":
                    cloud_data_center.put(
                        (packet_id, packet_type, A_cloud_service_time + propagation_delay))

                elif packet_type == "B":
                    cloud_data_center.put(
                        (packet_id, packet_type, B_cloud_service_fullprocess + propagation_delay))

            else:
                data.drop = data.drop + 1


        yield env.timeout(random.expovariate(arrival_rate))
        packet_id += 1


def edge_node(env, micro_data_center, cloud_data_center, node_id):
    while True:
        packet_id, packet_type, packet_processing_time = yield micro_data_center.get()

        yield env.timeout(packet_processing_time)
        print(f"Edge Node {node_id} processed packet {packet_id} of type {packet_type} at time {env.now}")

        if packet_type == 'B':
            yield cloud_data_center.put((packet_id, packet_type, B_cloud_service_partialprocess + propagation_delay))


def cloud_server(env, cloud_data_center):
    while True:
        packet_id, packet_type, packet_processing_time = yield cloud_data_center.get()

        yield env.timeout(packet_processing_time)
        print(
            f"Cloud Server processed {packet_type} packet {packet_id} (including propagation delay) at time {env.now}")


# Simulation setup


f = 0.5  # Fraction of packets of type B


simtime = 10000
# Recording data


# Run the simulation

env = simpy.Environment()
micro_data_center = simpy.Store(env)
cloud_data_center = simpy.Store(env)
env.process(packet_arrivals(env, micro_data_center, cloud_data_center, measurements, edge_buffer_size, cloud_buffer_size))
for node_id in range(num_edge_nodes):
    env.process(edge_node(env, micro_data_center, cloud_data_center, node_id + 1))
env.process(cloud_server(env, cloud_data_center))
env.run(until=simtime)

print ( 100*  measurements.drop/ ( measurements.N_arr_A+ measurements.N_arr_B))