Observability

A observabilidade é um aspecto fundamental da criação de sistemas confiáveis e mantêveis. O Agent Framework fornece suporte interno para observabilidade, permitindo que você monitore o comportamento de seus agentes.

Este guia orientará você pelas etapas para habilitar a observabilidade com o Agent Framework para ajudá-lo a entender como seus agentes estão executando e diagnosticar quaisquer problemas que possam surgir.

Integração do OpenTelemetry

O Agent Framework integra-se ao OpenTelemetry e, mais especificamente, o Agent Framework emite rastreamentos, logs e métricas de acordo com as Convenções Semânticas do OpenTelemetry GenAI.

Habilitar Observabilidade (C#)

Para habilitar a observabilidade para seu cliente de chat, você precisa criar o cliente de chat da seguinte maneira:

// Using the Azure OpenAI client as an example
var instrumentedChatClient = new AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredential())
    .GetChatClient(deploymentName)
    .AsIChatClient() // Converts a native OpenAI SDK ChatClient into a Microsoft.Extensions.AI.IChatClient
    .AsBuilder()
    .UseOpenTelemetry(sourceName: "MyApplication", configure: (cfg) => cfg.EnableSensitiveData = true)    // Enable OpenTelemetry instrumentation with sensitive data
    .Build();

Aviso

DefaultAzureCredential é conveniente para o desenvolvimento, mas requer uma consideração cuidadosa na produção. Em produção, considere o uso de uma credencial específica (por exemplo, ManagedIdentityCredential) para evitar problemas de latência, investigação de credenciais não intencionais e possíveis riscos de segurança de mecanismos de fallback.

Para habilitar a observabilidade do agente, você precisa criar o agente da seguinte maneira:

var agent = new ChatClientAgent(
    instrumentedChatClient,
    name: "OpenTelemetryDemoAgent",
    instructions: "You are a helpful assistant that provides concise and informative responses.",
    tools: [AIFunctionFactory.Create(GetWeatherAsync)]
).WithOpenTelemetry(sourceName: "MyApplication", enableSensitiveData: true);    // Enable OpenTelemetry instrumentation with sensitive data

Importante

Ao habilitar a observabilidade para seus clientes e agentes de chat, você poderá ver informações duplicadas, especialmente quando dados confidenciais estão habilitados. O contexto de chat (incluindo prompts e respostas) capturado pelo cliente de chat e pelo agente será incluído em ambos os intervalos. Dependendo de suas necessidades, você pode optar por habilitar a observabilidade somente no cliente de chat ou somente no agente para evitar a duplicação. Consulte as Convenções Semânticas do GenAI para obter mais detalhes sobre os atributos capturados para LLM e Agentes.

Observação

Habilite apenas dados confidenciais em ambientes de desenvolvimento ou teste, pois eles podem expor informações do usuário em logs de produção e rastreamentos. Os dados confidenciais incluem prompts, respostas, argumentos de chamada de função e resultados.

Configuração

Agora que seu cliente de chat e agente estão instrumentados, você pode configurar os exportadores OpenTelemetry para enviar os dados de telemetria para o back-end desejado.

Vestígios

Para exportar rastreamentos para o back-end desejado, você pode configurar o SDK do OpenTelemetry no código de inicialização do aplicativo. Por exemplo, para exportar rastreamentos para um recurso do Azure Monitor:

using Azure.Monitor.OpenTelemetry.Exporter;
using OpenTelemetry;
using OpenTelemetry.Trace;
using OpenTelemetry.Resources;
using System;

var SourceName = "MyApplication";

var applicationInsightsConnectionString = Environment.GetEnvironmentVariable("APPLICATION_INSIGHTS_CONNECTION_STRING")
    ?? throw new InvalidOperationException("APPLICATION_INSIGHTS_CONNECTION_STRING is not set.");

var resourceBuilder = ResourceBuilder
    .CreateDefault()
    .AddService(ServiceName);

using var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .SetResourceBuilder(resourceBuilder)
    .AddSource(SourceName)
    .AddSource("*Microsoft.Extensions.AI") // Listen to the Experimental.Microsoft.Extensions.AI source for chat client telemetry.
    .AddSource("*Microsoft.Extensions.Agents*") // Listen to the Experimental.Microsoft.Extensions.Agents source for agent telemetry.
    .AddAzureMonitorTraceExporter(options => options.ConnectionString = applicationInsightsConnectionString)
    .Build();

Dica

Dependendo do seu back-end, você pode usar exportadores diferentes. Para obter mais informações, consulte a documentação do .NET do OpenTelemetry. Para o desenvolvimento local, considere usar o Painel do Aspire.

Métricas

Da mesma forma, para exportar métricas para o back-end desejado, você pode configurar o SDK do OpenTelemetry no código de inicialização do aplicativo. Por exemplo, para exportar métricas para um recurso do Azure Monitor:

using Azure.Monitor.OpenTelemetry.Exporter;
using OpenTelemetry;
using OpenTelemetry.Metrics;
using OpenTelemetry.Resources;
using System;

var applicationInsightsConnectionString = Environment.GetEnvironmentVariable("APPLICATION_INSIGHTS_CONNECTION_STRING")
    ?? throw new InvalidOperationException("APPLICATION_INSIGHTS_CONNECTION_STRING is not set.");

var resourceBuilder = ResourceBuilder
    .CreateDefault()
    .AddService(ServiceName);

using var meterProvider = Sdk.CreateMeterProviderBuilder()
    .SetResourceBuilder(resourceBuilder)
    .AddSource(SourceName)
    .AddMeter("*Microsoft.Agents.AI") // Agent Framework metrics
    .AddAzureMonitorMetricExporter(options => options.ConnectionString = applicationInsightsConnectionString)
    .Build();

Logs

Os logs são capturados por meio da estrutura de log que você está usando, por exemplo Microsoft.Extensions.Logging. Para exportar logs para um recurso do Azure Monitor, você pode configurar o provedor de log no código de inicialização do aplicativo:

using Azure.Monitor.OpenTelemetry.Exporter;
using Microsoft.Extensions.Logging;

var applicationInsightsConnectionString = Environment.GetEnvironmentVariable("APPLICATION_INSIGHTS_CONNECTION_STRING")
    ?? throw new InvalidOperationException("APPLICATION_INSIGHTS_CONNECTION_STRING is not set.");

using var loggerFactory = LoggerFactory.Create(builder =>
{
    // Add OpenTelemetry as a logging provider
    builder.AddOpenTelemetry(options =>
    {
        options.SetResourceBuilder(resourceBuilder);
        options.AddAzureMonitorLogExporter(options => options.ConnectionString = applicationInsightsConnectionString);
        // Format log messages. This is default to false.
        options.IncludeFormattedMessage = true;
        options.IncludeScopes = true;
    })
    .SetMinimumLevel(LogLevel.Debug);
});

// Create a logger instance for your application
var logger = loggerFactory.CreateLogger<Program>();

Painel do Aspire

Considere usar o Painel do Aspire como uma maneira rápida de visualizar seus rastreamentos e métricas durante o desenvolvimento. Para saber mais, confira a documentação do Painel do Aspire. O Painel do Aspire recebe dados por meio de um Coletor OpenTelemetry, que você pode adicionar ao seu provedor de rastreamento da seguinte maneira:

using var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .SetResourceBuilder(resourceBuilder)
    .AddSource(SourceName)
    .AddSource("*Microsoft.Extensions.AI") // Listen to the Experimental.Microsoft.Extensions.AI source for chat client telemetry.
    .AddSource("*Microsoft.Extensions.Agents*") // Listen to the Experimental.Microsoft.Extensions.Agents source for agent telemetry.
    .AddOtlpExporter(options => options.Endpoint = new Uri("http://localhost:4317"))
    .Build();

Como começar

Veja um exemplo completo de um agente com OpenTelemetry habilitado no repositório do Agent Framework.

Dica

Consulte os exemplos do .NET para obter exemplos executáveis completos.

Dependências

Pacotes incluídos

Para habilitar a observabilidade em seu aplicativo Python, os seguintes pacotes OpenTelemetry são instalados por padrão:

Exportadores

Não instalamos exportadores por padrão para evitar dependências desnecessárias e possíveis problemas com a instrumentação automática. Há uma grande variedade de exportadores disponíveis para back-ends diferentes, para que você possa escolher os que melhor atendem às suas necessidades.

Alguns exportadores comuns que talvez você queira instalar com base em suas necessidades:

Para obter suporte ao protocolo gRPC: instalar opentelemetry-exporter-otlp-proto-grpc
Para suporte ao protocolo HTTP: instalar opentelemetry-exporter-otlp-proto-http
Para o Azure Application Insights: instalar azure-monitor-opentelemetry

Use o Registro OpenTelemetry para encontrar mais exportadores e pacotes de instrumentação.

Habilitar a Observabilidade (Python)

Cinco padrões para configurar a observabilidade

Identificamos várias maneiras de configurar a observabilidade em seu aplicativo, dependendo de suas necessidades:

1. Variáveis de ambiente OpenTelemetry Padrão (Recomendado)

A abordagem mais simples – configurar tudo por meio de variáveis de ambiente:

from agent_framework.observability import configure_otel_providers

# Reads OTEL_EXPORTER_OTLP_* environment variables automatically
configure_otel_providers()

Ou se você quiser apenas exportadores de console, defina a variável de ENABLE_CONSOLE_EXPORTERS ambiente:

ENABLE_CONSOLE_EXPORTERS=true

from agent_framework.observability import configure_otel_providers

# Console exporters are enabled via the ENABLE_CONSOLE_EXPORTERS env var
configure_otel_providers()

2. Exportadores Personalizados

Para obter mais controle sobre os exportadores, crie-os por conta própria e passe-os para configure_otel_providers():

from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.exporter.otlp.proto.grpc._log_exporter import OTLPLogExporter
from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
from agent_framework.observability import configure_otel_providers

# Create custom exporters with specific configuration
exporters = [
    OTLPSpanExporter(endpoint="http://localhost:4317", compression=Compression.Gzip),
    OTLPLogExporter(endpoint="http://localhost:4317"),
    OTLPMetricExporter(endpoint="http://localhost:4317"),
]

# These will be added alongside any exporters from environment variables
configure_otel_providers(exporters=exporters, enable_sensitive_data=True)

3. Configuração de terceiros

Muitos pacotes OpenTelemetry de terceiros têm seus próprios métodos de instalação. Você pode usar esses métodos primeiro e, em seguida, chamar enable_instrumentation() para ativar caminhos de código de instrumentação do Agent Framework:

from azure.monitor.opentelemetry import configure_azure_monitor
from agent_framework.observability import create_resource, enable_instrumentation

# Configure Azure Monitor first
configure_azure_monitor(
    connection_string="InstrumentationKey=...",
    resource=create_resource(),  # Uses OTEL_SERVICE_NAME, etc.
    enable_live_metrics=True,
)

# Then activate Agent Framework's telemetry code paths
# This is optional if ENABLE_INSTRUMENTATION and/or ENABLE_SENSITIVE_DATA are set in env vars
enable_instrumentation(enable_sensitive_data=False)

Para Langfuse:

from agent_framework.observability import enable_instrumentation
from langfuse import get_client

langfuse = get_client()

# Verify connection
if langfuse.auth_check():
    print("Langfuse client is authenticated and ready!")

# Then activate Agent Framework's telemetry code paths
enable_instrumentation(enable_sensitive_data=False)

4. Configuração manual

Para controle completo, você pode configurar manualmente exportadores, provedores e instrumentação. Use a função create_resource() auxiliar para criar um recurso com o nome e a versão de serviço apropriados. Consulte a documentação do OpenTelemetry Python para obter diretrizes detalhadas sobre instrumentação manual.

5. Instrumentação automática (código zero)

Use a ferramenta CLI do OpenTelemetry para instrumentar automaticamente seu aplicativo sem alterações de código:

opentelemetry-instrument \
    --traces_exporter console,otlp \
    --metrics_exporter console \
    --service_name your-service-name \
    --exporter_otlp_endpoint 0.0.0.0:4317 \
    python agent_framework_app.py

Consulte a documentação do Python opentelemetry de código zero para obter mais informações.

Usando rastreamentos e medidores

Depois que a observabilidade estiver configurada, você poderá criar intervalos ou métricas personalizadas:

from agent_framework.observability import get_tracer, get_meter

tracer = get_tracer()
meter = get_meter()
with tracer.start_as_current_span("my_custom_span"):
    # do something
    pass
counter = meter.create_counter("my_custom_counter")
counter.add(1, {"key": "value"})

Estes são wrappers da API OpenTelemetry que retornam um rastreador ou medidor do provedor global, com agent_framework definido como o nome da biblioteca de instrumentação por padrão.

Variáveis de ambiente

As seguintes variáveis de ambiente controlam a observabilidade do Agent Framework:

ENABLE_INSTRUMENTATION – O padrão é false, definido para habilitar a true instrumentação OpenTelemetry.
ENABLE_SENSITIVE_DATA - O padrão é false, definido para habilitar o true registro em log de dados confidenciais (prompts, respostas, argumentos de chamada de função e resultados). Tenha cuidado com essa configuração, pois ela pode expor dados confidenciais.
ENABLE_CONSOLE_EXPORTERS – O padrão é false, definido para habilitar a true saída do console para telemetria.
VS_CODE_EXTENSION_PORT – Porta para kit de ferramentas de IA ou integração de extensão do VS Code do Azure AI Foundry.

Observação

Informações confidenciais incluem prompts, respostas e muito mais e só devem ser habilitadas em ambientes de desenvolvimento ou teste. Não é recomendável habilitar isso em produção, pois pode expor dados confidenciais.

Variáveis de ambiente OpenTelemetry Padrão

A configure_otel_providers() função lê automaticamente variáveis de ambiente OpenTelemetry padrão:

Configuração OTLP (para o Aspire Dashboard, Jaeger etc.):

OTEL_EXPORTER_OTLP_ENDPOINT - Ponto de extremidade base para todos os sinais (por exemplo, http://localhost:4317)
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT - Ponto de extremidade específico de rastreamentos (substitui a base)
OTEL_EXPORTER_OTLP_METRICS_ENDPOINT - Ponto de extremidade específico de métricas (substitui base)
OTEL_EXPORTER_OTLP_LOGS_ENDPOINT - Ponto de extremidade específico de logs (substitui base)
OTEL_EXPORTER_OTLP_PROTOCOL – Protocolo a ser usado (grpc ou http, padrão: grpc)
OTEL_EXPORTER_OTLP_HEADERS - Cabeçalhos para todos os sinais (por exemplo, key1=value1,key2=value2)

Identificação de serviço:

OTEL_SERVICE_NAME - Nome do serviço (padrão: agent_framework)
OTEL_SERVICE_VERSION – Versão do serviço (padrão: versão do pacote)
OTEL_RESOURCE_ATTRIBUTES - Atributos de recursos adicionais

Consulte a especificação OpenTelemetry para obter mais detalhes.

Configuração do Microsoft Foundry

O Microsoft Foundry tem suporte interno para rastreamento com visualização para seus intervalos.

Verifique se o Foundry está configurado com uma instância do Azure Monitor, confira detalhes

Instalar o pacote `azure-monitor-opentelemetry`:

pip install azure-monitor-opentelemetry

Configurar a observabilidade diretamente do `AzureAIClient`:

Para projetos do Azure AI Foundry, você pode configurar a observabilidade diretamente do AzureAIClient:

from agent_framework.azure import AzureAIClient
from azure.ai.projects.aio import AIProjectClient
from azure.identity.aio import AzureCliCredential

async def main():
    async with (
        AzureCliCredential() as credential,
        AIProjectClient(endpoint="https://<your-project>.foundry.azure.com", credential=credential) as project_client,
        AzureAIClient(project_client=project_client) as client,
    ):
        # Automatically configures Azure Monitor with connection string from project
        await client.configure_azure_monitor(enable_live_metrics=True)

Dica

Os argumentos para client.configure_azure_monitor() os quais são passados para a função subjacente configure_azure_monitor() do pacote, consulte a azure-monitor-opentelemetrydocumentação para obter detalhes, cuidamos de definir a cadeia de conexão e o recurso.

Configure o Azure Monitor e, opcionalmente, habilite a instrumentação:

Para projetos que não são de IA do Azure com o Application Insights, verifique se você configurou um agente personalizado no Foundry, confira os detalhes.

Em seguida, execute seu agente com a mesma ID do agente OpenTelemetry registrada no Foundry e configure o azure Monitor da seguinte maneira:

from azure.monitor.opentelemetry import configure_azure_monitor
from agent_framework.observability import create_resource, enable_instrumentation

configure_azure_monitor(
    connection_string="InstrumentationKey=...",
    resource=create_resource(),
    enable_live_metrics=True,
)
# optional if you do not have ENABLE_INSTRUMENTATION in env vars
enable_instrumentation()

# Create your agent with the same OpenTelemetry agent ID as registered in Foundry
agent = Agent(
    chat_client=...,
    name="My Agent",
    instructions="You are a helpful assistant.",
    id="<OpenTelemetry agent ID>"
)
# use the agent as normal

Painel do Aspire

Para desenvolvimento local sem a instalação do Azure, você pode usar o Aspire Dashboard, que é executado localmente por meio do Docker e fornece uma excelente experiência de exibição de telemetria.

Configurando o Painel do Aspire com o Docker

# Pull and run the Aspire Dashboard container
docker run --rm -it -d \
    -p 18888:18888 \
    -p 4317:18889 \
    --name aspire-dashboard \
    mcr.microsoft.com/dotnet/aspire-dashboard:latest

Este comando iniciará o painel com:

Interface do usuário da Web: disponível em http://localhost:18888
Ponto de extremidade OTLP: disponível http://localhost:4317 para seus aplicativos enviarem dados de telemetria

Configurando seu aplicativo

Defina as seguintes variáveis de ambiente:

ENABLE_INSTRUMENTATION=true
OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317

Ou inclua-os no .env arquivo e execute o exemplo.

Depois que o exemplo terminar de ser executado, navegue até http://localhost:18888 um navegador da Web para ver os dados de telemetria. Siga o guia de exploração do Aspire Dashboard para autenticar no painel e começar a explorar seus rastreamentos, logs e métricas.

Intervalos e métricas

Depois que tudo estiver configurado, você começará a ver intervalos e métricas sendo criados automaticamente para você, os intervalos são:

invoke_agent <agent_name>: este é o intervalo de nível superior para cada invocação de agente, ele conterá todos os outros intervalos como crianças.
chat <model_name>: esse intervalo é criado quando o agente chama o modelo de chat subjacente, ele conterá o prompt e a resposta como atributos, se enable_sensitive_data for definido Truecomo .
execute_tool <function_name>: esse intervalo é criado quando o agente chama uma ferramenta de função, ele conterá os argumentos de função e resultará como atributos, se enable_sensitive_data for definido como True.

As métricas criadas são:

Para o cliente de chat e chat as operações:
- gen_ai.client.operation.duration (histograma): essa métrica mede a duração de cada operação, em segundos.
- gen_ai.client.token.usage (histograma): essa métrica mede o uso do token, em número de tokens.
Para invocação de função durante as execute_tool operações:
- agent_framework.function.invocation.duration (histograma): essa métrica mede a duração de cada execução de função, em segundos.

Exemplo de saída de rastreamento

Ao executar um agente com a observabilidade habilitada, você verá dados de rastreamento semelhantes à seguinte saída do console:

{
    "name": "invoke_agent Joker",
    "context": {
        "trace_id": "0xf2258b51421fe9cf4c0bd428c87b1ae4",
        "span_id": "0x2cad6fc139dcf01d",
        "trace_state": "[]"
    },
    "kind": "SpanKind.CLIENT",
    "parent_id": null,
    "start_time": "2025-09-25T11:00:48.663688Z",
    "end_time": "2025-09-25T11:00:57.271389Z",
    "status": {
        "status_code": "UNSET"
    },
    "attributes": {
        "gen_ai.operation.name": "invoke_agent",
        "gen_ai.system": "openai",
        "gen_ai.agent.id": "Joker",
        "gen_ai.agent.name": "Joker",
        "gen_ai.request.instructions": "You are good at telling jokes.",
        "gen_ai.response.id": "chatcmpl-CH6fgKwMRGDtGNO3H88gA3AG2o7c5",
        "gen_ai.usage.input_tokens": 26,
        "gen_ai.usage.output_tokens": 29
    }
}

Este rastreamento mostra:

Identificadores de rastreamento e intervalo: para correlacionar operações relacionadas
Informações de tempo: quando a operação foi iniciada e encerrada
Metadados do agente: ID do agente, nome e instruções
Informações do modelo: o sistema de IA usado (OpenAI) e a ID de resposta
Uso de token: contagens de token de entrada e saída para acompanhamento de custos

Samples

Há vários exemplos no microsoft/agent-framework repositório que demonstram essas funcionalidades. Para obter mais informações, consulte a pasta de exemplos de observabilidade. Essa pasta inclui exemplos para usar a telemetria de código zero também.

Exemplo completo

# Copyright (c) Microsoft. All rights reserved.

import asyncio
from random import randint
from typing import Annotated

from agent_framework import Agent, tool
from agent_framework.observability import configure_otel_providers, get_tracer
from agent_framework.openai import OpenAIChatClient
from opentelemetry.trace import SpanKind
from opentelemetry.trace.span import format_trace_id
from pydantic import Field

"""
This sample shows how you can observe an agent in Agent Framework by using the
same observability setup function.
"""


# NOTE: approval_mode="never_require" is for sample brevity. Use "always_require" in production; see samples/02-agents/tools/function_tool_with_approval.py and samples/02-agents/tools/function_tool_with_approval_and_sessions.py.
@tool(approval_mode="never_require")
async def get_weather(
    location: Annotated[str, Field(description="The location to get the weather for.")],
) -> str:
    """Get the weather for a given location."""
    await asyncio.sleep(randint(0, 10) / 10.0)  # Simulate a network call
    conditions = ["sunny", "cloudy", "rainy", "stormy"]
    return f"The weather in {location} is {conditions[randint(0, 3)]} with a high of {randint(10, 30)}°C."


async def main():
    # calling `configure_otel_providers` will *enable* tracing and create the necessary tracing, logging
    # and metrics providers based on environment variables.
    # See the .env.example file for the available configuration options.
    configure_otel_providers()

    questions = ["What's the weather in Amsterdam?", "and in Paris, and which is better?", "Why is the sky blue?"]

    with get_tracer().start_as_current_span("Scenario: Agent Chat", kind=SpanKind.CLIENT) as current_span:
        print(f"Trace ID: {format_trace_id(current_span.get_span_context().trace_id)}")

        agent = Agent(
            client=OpenAIChatClient(),
            tools=get_weather,
            name="WeatherAgent",
            instructions="You are a weather assistant.",
            id="weather-agent",
        )
        thread = agent.create_session()
        for question in questions:
            print(f"\nUser: {question}")
            print(f"{agent.name}: ", end="")
            async for update in agent.run(
                question,
                session=thread,
                stream=True,
            ):
                if update.text:
                    print(update.text, end="")


if __name__ == "__main__":
    asyncio.run(main())

Próximas etapas

Visão geral das ferramentas

Comentários

Esta página foi útil?

Last updated on 2026-02-13

Compartilhar via

Observability

Integração do OpenTelemetry

Habilitar Observabilidade (C#)

Configuração

Vestígios

Métricas

Logs

Painel do Aspire

Como começar

Dependências

Pacotes incluídos

Exportadores

Habilitar a Observabilidade (Python)

Cinco padrões para configurar a observabilidade

1. Variáveis de ambiente OpenTelemetry Padrão (Recomendado)

2. Exportadores Personalizados

3. Configuração de terceiros

4. Configuração manual

5. Instrumentação automática (código zero)

Usando rastreamentos e medidores

Variáveis de ambiente

Variáveis de ambiente OpenTelemetry Padrão

Configuração do Microsoft Foundry

Instalar o pacote azure-monitor-opentelemetry:

Configurar a observabilidade diretamente do AzureAIClient:

Configure o Azure Monitor e, opcionalmente, habilite a instrumentação:

Painel do Aspire

Configurando o Painel do Aspire com o Docker

Configurando seu aplicativo

Intervalos e métricas

Exemplo de saída de rastreamento

Samples

Exemplo completo

Próximas etapas

Comentários

Recursos adicionais

Instalar o pacote `azure-monitor-opentelemetry`:

Configurar a observabilidade diretamente do `AzureAIClient`: