Ir para o conteúdo

Lab 6.2: Gerando Gráficos para criar reports

Coletando dados de Warning:

Inicialmente, iremos criar um gráfico indicando o número de avisos por bot. Para gerar o gráfico, é necessário coletar os dados na rota da API que retorna os avisos, e em seguida, iremos agrupar os avisos por bot, como no código Python abaixo:

def main():

    # Obtendo as informações de Warnings
    warning_route = f"{server}/api/v2/alerts"
    response_warns =  requests.get(warning_route, headers=headers)
    warns = json.loads(response_warns.content)
    warns_contents =  warns['content']
    warns_infos = []
    for item in warns_contents:
        id = item['botId']
        category = item['type']
        data = {"id": f"{id}",  "type": f"{category}"}
        warns_infos.append(data)

Neste bloco:

  • Definimos a rota da API para warnings: /api/v2/alerts.
  • Fazemos uma requisição GET usando requests.get().
  • A resposta é carregada como JSON usando json.loads().
  • Iteramos sobre o conteúdo dos warnings warns['content'] para extrair o botId (ID da automação) e o type (categoria do warning), armazenando-os em uma lista de dicionários chamada warns_infos.

Vamos utilizar os dados obtidos para gerar gráficos de barra de Avisos por Bot e em seguida, gerar um gráfico Pizza para exibir a proporção de tipos de Warnings.

Gerando gráfico de barra para Warnings por Bot:

Para gerar o gráfico de Warnings por Bot, vamos começar agrupando as informações armazenadas na lista warns_infos, como indicada no código abaixo:

    # Contar a frequência de alertas por ID de automação
    alert_counts = Counter(item['id'] for item in warns_infos)
    bots = list(alert_counts.keys())
    alert_values = list(alert_counts.values())
No código acima, foi feito:
  • Emm alert_counts, inicializamos o Counter(item['id'] for item in warns_infos) para criar um dicionário onde as chaves são os IDs das automações e os valores são as contagens de warnings para cada ID.
  • Extraímos as chaves (IDs das automações) para bots e os valores (contagens) para alert_values.

Em seguida, vamos gerar os gráficos de barra, passando os valores dos botID e contagem de warnings:

    # Gráfico de Barras para Alertas por Automação
    fig_alerts = go.Figure(data=[go.Bar(x=bots, y=alert_values, marker_color='mediumturquoise')])
    fig_alerts.update_layout(
        title_text='Total de Alertas por Automação',
        xaxis_title='ID da Automação',
        yaxis_title='Quantidade de Alertas',
        template='plotly_dark' # Estilo do gráfico
    )
    fig_alerts.show() # Exibe o gráfico de alertas

Coletando os dados de erros:

Para coletar os dados de Warning, iremos realizar o mesmo procedimento feito com os Warnings, ou seja, iremos configurar o endpoint para obter os erros e em seguida, gerar os gráficos.

Inicialmente, iremos fazer a requisição para listar os erros registrados, como indicado no código abaixo:

    errors_route = f"{server}/api/v2/error"
    response_errors =  requests.get(errors_route, headers=headers)
    errors = json.loads(response_errors.content)
    errors_content =  errors['content']
    errors_infos = []
    for item in errors_content:
        id = item['botId']
        category = item['type']
        data = {"id": f"{id}", "Error category": f"{category}"}  
        errors_infos.append(data)

No código, foi feito:

  • Definimos a rota da API para erros /api/v2/error.

  • Realizamos a requisição e processamos a resposta JSON da mesma forma que fizemos para os warnings, preenchendo a lista errors_infos.

Criando gráfico de barras para exibir erros por Bots:

Vamos contabilizar a quantidade de erros por bots, com o código Python abaixo:

    # Contar a frequência de erros por ID de automação
    error_counts = Counter(item['id'] for item in errors_infos)
    bots = list(error_counts.keys())
    error_values = list(error_counts.values())

No código acima, fizemos a contabilização de erros por bot com o mesmo processo indicado nos Warnings.

Criando um gráfico de Pizza para agrupar os Tipos de erro por Bot:

A seguir, iremos criar um gráfico de Pizza para indicar a proporção dos tipos de erros gerados. Veja o código Python abaixo para criar o gráfico:

    type_errors = Counter(item['Error category'] for item in errors_infos)
    categories = list(type_errors.keys())
    amounts = list(type_errors.values())

    pie_chart = go.Figure(data=[go.Pie(labels=categories, values=amounts)])
    colors = ['gold', 'mediumturquoise', 'darkorange', 'lightgreen']

    pie_chart.update_traces(hoverinfo='label+percent', textinfo='value', textfont_size=20,
                    marker=dict(colors=colors, line=dict(color='#000000', width=2)))
    pie_chart.show()
No código acima, fizemos:

  • Contagem de Erros (collections.Counter):

    • Importa Counter para contar eficientemente a ocorrência de cada categoria de erro presente em errors_infos (uma lista de dicionários).
    • O resultado type_errors é um dicionário com categorias como chaves e suas contagens como valores.

  • Preparação dos Dados (categories, amounts):

    • Extrai as chaves (categories) e os valores (amounts) de type_errors para serem usados como rótulos e tamanhos das fatias do gráfico, respectivamente.

  • Criação do Gráfico (plotly.graph_objects):

    • Importa plotly.graph_objects como go.
    • Cria um objeto go.Figure contendo um go.Pie (gráfico de pizza) com os labels (categorias) e values (contagens) definidos.

  • Definição de Cores (colors):

    • Define uma lista de cores que serão aplicadas às fatias do gráfico.

  • Personalização do Gráfico (update_traces):

    • pie_chart.update_traces(): Personaliza a aparência das fatias do gráfico:
      • hoverinfo='label+percent': Exibe o rótulo e a porcentagem ao passar o mouse.
      • textinfo='value': Mostra a contagem de erros diretamente na fatia.
      • textfont_size=20: Define o tamanho da fonte do texto na fatia.
      • marker=dict(colors=colors, line=dict(color='#000000', width=2)): Aplica as cores definidas e adiciona uma borda preta de 2px a cada fatia.

  • Exibição do Gráfico (show):

    • pie_chart.show(): Renderiza e exibe o gráfico de pizza interativo.

Código-fonte completo:

Abaixo, segue o código-fonte completo do Report de informações dos bots:

import requests
import json
import plotly.graph_objects as go
from collections import Counter

def main():

    # Configurando variáveis
    login="<SEU_LOGIN>"
    key="<SUA_KEY>"
    server = "https://developers.botcity.dev"

    # Configeurando rota de login
    login_url =f"{server}/api/v2/workspace/login" 
    body = {
        "login": "f{login}",
        "key": "f{key}"
    }
    response = requests.post(url=login_url, json={"login": f"{login}","key": f"{key}"},auth=None)
    content = json.loads(response.content)

    # Criando o header com o Token e organization
    token = content['accessToken']
    org = content['organizationLabel']

    headers = {'token':f'{token}','organization':f'{org}'}


    # Criando Dashboards com a quantidade de warnings por automação:
    warning_route = f"{server}/api/v2/alerts"
    response_warns =  requests.get(warning_route, headers=headers)
    warns = json.loads(response_warns.content)
    warns_contents =  warns['content']
    warns_infos = []
    for item in warns_contents:
        id = item['botId']
        category = item['type']
        data = {"id": f"{id}",  "type": f"{category}"}
        warns_infos.append(data)


    # Contar a frequência de alertas por ID de automação
    alert_counts = Counter(item['id'] for item in warns_infos)
    bots = list(alert_counts.keys())
    alert_values = list(alert_counts.values())

    # Gráfico de Barras para Alertas por Automação
    fig_alerts = go.Figure(data=[go.Bar(x=bots, y=alert_values, marker_color='mediumturquoise')])
    fig_alerts.update_layout(
        title_text='Total de Alertas por Automação',
        xaxis_title='ID da Automação',
        yaxis_title='Número de Alertas',
        template='plotly_dark' # Estilo do gráfico
    )
    fig_alerts.show() # Exibe o gráfico de alertas


    errors_route = f"{server}/api/v2/error"
    response_errors =  requests.get(errors_route, headers=headers)
    errors = json.loads(response_errors.content)
    errors_content =  errors['content']
    errors_infos = []
    for item in errors_content:
        id = item['botId']
        category = item['type']
        data = {"id": f"{id}", "Error category": f"{category}"}  
        errors_infos.append(data)


    # Contar a frequência de erros por ID de automação
    error_counts = Counter(item['id'] for item in errors_infos)
    bots = list(error_counts.keys())
    error_values = list(error_counts.values())

    # --- Geração dos Gráficos com Plotly ---

    # Gráfico de Barras para Erros por Automação
    fig_errors = go.Figure(data=[go.Bar(x=bots, y=error_values)])
    fig_errors.update_layout(
        title_text='Total de Erros por Automação',
        xaxis_title='ID da Automação',
        yaxis_title='Número de Erros',
        template='plotly_white' # Estilo do gráfico
    )
    fig_errors.show() # Exibe o gráfico de erros


    # Pie Chart para tipos de erros:
    type_errors = Counter(item['Error category'] for item in errors_infos)
    categories = list(type_errors.keys())
    amounts = list(type_errors.values())

    pie_chart = go.Figure(data=[go.Pie(labels=categories, values=amounts)])
    colors = ['gold', 'mediumturquoise', 'darkorange', 'lightgreen']

    pie_chart.update_traces(hoverinfo='label+percent', textinfo='value', textfont_size=20,
                    marker=dict(colors=colors, line=dict(color='#000000', width=2)))
    pie_chart.show()


if __name__ == "__main__":
    main()