Menu Docs
Página inicial do Docs
/
MongoDB Atlas
/
Serviços Atlas App
/
Monitore a atividade da aplicação

Exibir logs do aplicativo

Nesta página

  • App Services UI
  • Filtrar registros
  • Limite o número de entradas de registro
  • Baixar registros
  • CLI de serviços de aplicativos
  • Visualizar registros recentes
  • A cauda registra em tempo real
  • Exibir registros de erros
  • Filtrar registros por tipo
  • Visualizar registros de um intervalo de datas
  • App Services API
  • Obter registros recentes
  • Obter registros para um intervalo de datas
  • Obter registros paginados

App Services UI

Você pode visualizar, filtrar, pesquisar e baixar os registros de um aplicativo na interface do usuário do App Services. Para ver os registros da sua aplicação, clique em Logs no menu de navegação esquerdo.

Exibir registros na interface do usuário do App Services

Filtrar registros

Os menus suspensos permitem a filtragem por tipos predefinidos de entrada de registro e o status das entradas. Você também pode especificar um intervalo de datas, filtrar por ID do usuário e mostrar apenas as entradas associadas a um ID de solicitação específico.

Limite o número de entradas de registro

No campo de texto com o texto de espaço reservado Max # of Logs, insira o número máximo de resultados que você deseja exibir na página. Se houver mais registros além do seu limite, você verá um botão Load More na parte inferior da lista de entradas de registro.

Baixar registros

Clique no botão de download, à direita do botão Apply , para baixar as entradas de registro que atendem aos seus critérios de filtro (ou todas as entradas de registro, se você não tiver especificado nenhum filtro). Quando você clica nesse botão, uma caixa de diálogo é exibida confirmando os filtros que serão aplicados e solicitando que você (opcionalmente) limite o número de resultados. A collection resultante de entradas de registro está em um .zip que contém um único arquivo JSON.

Baixar registros na interface do usuário do App Services

CLI de serviços de aplicativos

Você pode acessar os registros de um aplicativo em seu terminal ou um script de shell com a App Services CLI.

Visualizar registros recentes

Para retornar as 100 entradas de registro mais recentes do seu aplicativo, execute appservices logs list.

appservices logs list

A cauda registra em tempo real

Você pode usar o sinalizador --tail para abrir um fluxo que exibe os registros do aplicativo à medida que eles chegam.

appservices logs list --tail

Exibir registros de erros

Você pode usar o sinalizador --errors para visualizar somente registros de erros. Se você não especificar o sinalizador, o comando retornará os registros de erros e os registros regulares.

appservices logs list --errors

Filtrar registros por tipo

Você pode usar o sinalizador --type para visualizar registros de um ou mais tipos específicos. Se você não especificar um tipo, o comando retornará registros de todos os tipos.

Os seguintes tipos são válidos:

  • auth

  • function

  • push

  • service

  • trigger

  • graphql

  • sync

  • schema

  • trigger_error_handler

  • log_forwarder

  • endpoint

appservices logs list --type=function --type=trigger

Visualizar registros de um intervalo de datas

Você pode usar os sinalizadores --start e --end para visualizar registros de um intervalo de datas. As bandeiras aceitam strings ISODate e você pode usá-las separadamente ou juntas.

appservices logs list --start="2021-01-01T00:00:00.000+0000" --end="2021-02-01T00:00:00.000+0000"

App Services API

Você pode acessar os registros de um aplicativo por HTTPS chamando osendpoints de registros da API de administrador .

Para usar a API Admin, você precisará do ID do projeto, do ID do aplicativo e das credenciais de autenticação. Para saber como encontrá-los, consulte IDs de projetos e aplicativos e Obter tokens de autenticação.

Os exemplos nesta seção usam as seguintes funções auxiliares em uma Função:

async function authenticate(publicApiKey, privateApiKey) {
  const result = await context.http.post({
    url: `${ADMIN_API_BASE_URL}/auth/providers/mongodb-cloud/login`,
    headers: {
      "Content-Type": ["application/json"],
      "Accept": ["application/json"],
    },
    body: {
      "username": publicApiKey,
      "apiKey": privateApiKey,
    },
    encodeBodyAsJSON: true
  })
  return EJSON.parse(result.body.text());
}
function formatQueryString(queryParams) {
  const params = Object.entries(queryParams);
  return params.length > 0
    ? "?" + params.map(([a, b]) => `${a}=${b}`).join("&")
    : ""
}

Obter registros recentes

Para retornar as 100 entradas de registro mais recentes para seu aplicativo, chame o endpoint Logging sem parâmetros adicionais:

const ADMIN_API_BASE_URL = "https://services.cloud.mongodb.com/api/admin/v3.0";
exports = async function() {
  // Get values that you need for requests
  const projectId = "<Atlas Project ID>";
  const appId = "<App ID>";
  const publicApiKey = "<Atlas Public API Key>";
  const privateApiKey = "<Atlas Private API Key>";
  // Authenticate with the Atlas API Key
  const { access_token } = await authenticate(publicApiKey, privateApiKey);
  // Get logs for your App
  const logsEndpoint = `${ADMIN_API_BASE_URL}/groups/${projectId}/apps/${appId}/logs`;
  const  request = {
    "url": logsEndpoint,
    "headers": {
      "Authorization": [`Bearer ${access_token}`]
    }
  };
  const result = await context.http.get(request);
  const logs = EJSON.parse(result.body.text());
  return logs;
}

Obter registros para um intervalo de datas

Para retornar entradas de registro para um intervalo de datas específico, chame o endpoint do registro com um ou ambos os campos start_date e end_date :

Observação

Paginação de resultados

Se o intervalo de datas especificado incluir mais de 100 entradas de registro, você precisará executar várias query para acessar todas as entradas. Para saber como, consulte Obter registros paginados.

const ADMIN_API_BASE_URL = "https://services.cloud.mongodb.com/api/admin/v3.0";
exports = async function() {
  // Get values that you need for requests
  const projectId = "<Atlas Project ID>";
  const appId = "<App ID>";
  const publicApiKey = "<Atlas Public API Key>";
  const privateApiKey = "<Atlas Private API Key>";
  // Authenticate with the Atlas API Key
  const { access_token } = await authenticate(publicApiKey, privateApiKey);
  // Get logs for your App
  const logsEndpoint = `${ADMIN_API_BASE_URL}/groups/${projectId}/apps/${appId}/logs`;
  const  request = {
    "url": logsEndpoint + formatQueryString({
      start_date: "2019-07-01",
      end_date: "2019-07-31",
    }),
    "headers": {
      "Authorization": [`Bearer ${access_token}`]
    }
  };
  const result = await context.http.get(request);
  const logs = EJSON.parse(result.body.text());
  return logs;
}

Obter registros paginados

O App Services retorna um máximo de 100 entradas de registro para cada solicitação. Se uma query corresponder a mais de 100 entradas de registro, a API retornará a primeira "página" de 100 resultados e incluirá parâmetros adicionais na resposta que você pode fornecer para obter a(s) próxima(s) página(s) de até 100 entradas.

Observação

Respostas paginadas

Uma resposta paginada se assemelha ao seguinte documento, onde nextEndDate e nextSkip são opcionais:

{
  logs: [<Log Entry>, ...],
  nextEndDate: "<End date of the next page>",
  nextSkip: <Offset of the next page>,
}
const ADMIN_API_BASE_URL = "https://services.cloud.mongodb.com/api/admin/v3.0";
exports = async function() {
  // Get values that you need for requests
  const projectId = "<Atlas Project ID>";
  const appId = "<App ID>";
  const publicApiKey = "<Atlas Public API Key>";
  const privateApiKey = "<Atlas Private API Key>";
  // Authenticate with the Atlas API Key
  const { access_token } = await authenticate(publicApiKey, privateApiKey);
  // Get logs for your App
  const pager = new LogPager(projectId, appId, access_token);
  const firstPage = await pager.getNextPage();
  const secondPage = await pager.getNextPage(firstPage);
  const thirdPage = await pager.getNextPage(secondPage);
  const allLogs = await pager.getAllLogs();
}
class LogPager {
  constructor(projectId, appId, access_token, queryParams={}) {
    this.logsEndpoint = `${ADMIN_API_BASE_URL}/groups/${projectId}/apps/${appId}/logs`;
    this.queryParams = queryParams;
    this.authHeaders = { Authorization: [`Bearer ${access_token}`] }
  }
  async getNextPage(prevPage) {
    const { nextEndDate, nextSkip } = prevPage || {};
    if(prevPage && !nextEndDate) {
      throw new Error("Paginated API does not have any more pages.")
    }
    const request = {
      "headers": this.authHeaders,
      "url": this.logsEndpoint + formatQueryString({
        ...this.queryParams,
        end_date: nextEndDate,
        skip: nextSkip,
      }),
    }
    const result = await context.http.get(request);
    const nextPage = EJSON.parse(result.body.text());
    return nextPage
  }
  async getAllLogs() {
    // Note: If your query parameters match too many logs this might time out
    let logs = []
    let hasNext = true;
    let prevPage = null
    while(hasNext) {
      const page = await getNextPage(prevPage);
      logs = logs.concat(page.logs);
      hasNext = page.nextEndDate
      prevPage = page
    }
    return logs;
  }
}

Voltar

Monitore a atividade da aplicação

Próximo

Encaminhar registros para um serviço