> ## Documentation Index > Fetch the complete documentation index at: https://docs.appsignal.com/llms.txt > Use this file to discover all available pages before exploring further. # Agrupamento com namespaces Namespaces são uma forma de agrupar incidentes de erro, incidentes de desempenho e métricas de ações. O AppSignal usa três [namespaces] por padrão: * `web` para requisições web * `frontend` para JavaScript de front-end * `background` para jobs em segundo plano Os aplicativos podem ter qualquer número de namespaces. Por exemplo, você pode ter um namespace separado para o painel de administração do seu aplicativo, API ou tarefas agendadas. Este guia abordará as etapas necessárias para reportar ações em namespaces personalizados. Quer saber mais sobre o que os namespaces podem ser usados? Confira esta lista: [O que você pode fazer com namespaces?](/application/namespaces#what-can-you-do-with-namespaces) App Graphs Namespaces ## Configurando namespaces Os namespaces são definidos pelo código do seu aplicativo. Com pequenos helpers, você pode personalizar o namespace de uma ação. Este guia ensinará como dividir as requisições em diferentes namespaces. Para este guia, criaremos um namespace "admin" e um namespace "critical" para jobs em segundo plano. Os nomes de namespace só podem conter letras (a-z) e sublinhados
Não recomendamos ter mais de **15** namespaces por aplicativo. #### Configurações por linguagem * [Ruby](#ruby) * [Elixir](#elixir) * [Node.js](#nodejs) * [Python](#python) * [JavaScript de front-end](#front-end-javascript) * [Go](#go) * [Java](#java) * [PHP](#php) ### Ruby No Rails, podemos usar o callback `before_action` para chamar um método antes que uma requisição seja tratada. No exemplo de código abaixo, criamos um `before_action` que chama o método `set_appsignal_namespace`. Neste método, chamamos o [método helper `Appsignal.set_namespace`][ruby helper] para configurar "admin" como o namespace para esta requisição. Isso também funciona se outros controllers forem subclasses do `AdminController`. ```ruby Ruby theme={null} # Em um controller Rails # app/controllers/admin_controller.rb class AdminController < ApplicationController before_action :set_appsignal_namespace def set_appsignal_namespace # Configura todas as ações neste controller para reportar # no namespace "admin" Appsignal.set_namespace("admin") end # Qualquer outra ação do controller end ``` Em seguida, definiremos o namespace do código executado pelos workers em segundo plano do Sidekiq do nosso aplicativo. Para definir corretamente o namespace dos erros disparados em nosso worker em segundo plano, devemos definir o namespace antes que qualquer outro código seja executado. No exemplo de código do worker Sidekiq abaixo, fazemos isso imediatamente no método perform, na linha 7. ```ruby Ruby theme={null} # Em um worker Sidekiq # app/workers/critical_worker.rb class CriticalWorker include Sidekiq::Worker def perform # Configura os jobs deste worker para reportar no namespace "critical" Appsignal.set_namespace("critical") # O código real do worker end end ``` Também é possível configurar o namespace ao criar uma transação usando o helper [`Appsignal.monitor`](https://rubydoc.info/gems/appsignal/Appsignal/Helpers/Instrumentation#monitor-instance_method). Ele aceita o namespace como um argumento de palavra-chave. ```ruby Ruby theme={null} # Ao criar uma nova transação Appsignal.monitor(namespace: "admin") do # Seu código a ser instrumentado end ``` Para transações que já foram criadas, você pode usar o método `set_namespace` para configurar o namespace da transação, como no exemplo abaixo: ```ruby Ruby theme={null} # Ao alterar o namespace posteriormente para uma transação transaction.set_namespace("slow_admin") ``` ##### Uma nota sobre a localização do helper Os helpers `set_namespace` usados neste guia podem ser chamados em qualquer ação que faça parte de uma amostra do AppSignal. Recomendamos chamar isso o mais cedo possível na requisição ou job em segundo plano, para que a transação seja configurada com o namespace fornecido antes que qualquer erro ocorra. Caso contrário, se ocorrer um erro ou qualquer outra coisa que pare o processo, a transação será enviada ao AppSignal antes que o helper `set_namespace` seja chamado, e a amostra será reportada sob o namespace padrão. #### Leia mais * [Documentação do método helper `Appsignal.set_namespace`][ruby helper] ### Elixir Em controllers Phoenix, usamos um `plug` para chamar uma função antes que a requisição seja tratada pelo Phoenix. No exemplo de código abaixo, usamos `plug` para chamar a função `set_appsignal_namespace` (linha 5). Nesta função, chamamos o [helper `Appsignal.Span.set_namespace`][elixir helper] para configurar o namespace para esta requisição (linha 10). ```elixir Elixir theme={null} # Em um controller Phoenix defmodule AppsignalPhoenixExampleWeb.AdminController do use AppsignalPhoenixExampleWeb, :controller plug :set_appsignal_namespace defp set_appsignal_namespace(conn, _params) do # Configura todas as ações neste controller para reportar # no namespace "admin" Appsignal.Span.set_namespace(Appsignal.Tracer.root_span(), "admin") conn end # ... end ``` Em seguida, configuraremos o namespace para um job em segundo plano. Para capturar qualquer erro dentro do job dentro do namespace desejado, `Appsignal.Span.set_namespace` deve ser chamado no início da função antes de qualquer outro código, como na linha 4 do exemplo de código abaixo: ```elixir Elixir theme={null} defmodule MyApp.CriticalJob do def run do # Configura os jobs deste worker para reportar no namespace "critical" Appsignal.Span.set_namespace(Appsignal.Tracer.root_span(), "critical") # O código real do worker end end ``` Também é possível configurar o namespace ao criar uma transação. Consulte a documentação para [decorators][elixir namespace_decorator] ou [helpers de instrumentação][elixir namespace_helper] para mais informações sobre como configurar namespaces. #### Uma nota sobre a localização do helper Os helpers `set_namespace` usados neste guia podem ser chamados em qualquer ação que inicie uma transação do AppSignal. Recomendamos chamar isso o mais cedo possível na requisição ou job em segundo plano, para que a transação seja configurada com o namespace fornecido antes que qualquer erro ocorra. Caso contrário, se ocorrer um erro—ou qualquer outra coisa que pare o processo—a transação será enviada ao AppSignal antes que o código `set_namespace` seja chamado e será reportada sob o namespace padrão. #### Leia mais * [Documentação do método helper `Appsignal.Span.set_namespace`][elixir helper] * [Elixir Namespace Decorator][elixir namespace_decorator] * [Elixir Namespace Instrumentation Helper][elixir namespace_helper] ### Node.js Em aplicativos Node.js, o AppSignal funciona com o OpenTelemetry, que usa spans para rastrear metadados, como a qual namespace um span pertence. Use a função helper `setNamespace` como no exemplo abaixo para definir o namespace para o trace do span ativo. ```javascript Node.js theme={null} import { setNamespace } from "@appsignal/nodejs"; setNamespace("custom-namespace"); ``` [Leia mais sobre como os spans funcionam em Node.js](/nodejs/3.x/instrumentation/instrumentation). ### PHP Em aplicativos PHP, o AppSignal funciona com o OpenTelemetry, que usa spans para rastrear metadados, como a qual namespace um span pertence. Use o método helper `Appsignal::setNamespace` para definir o namespace para o trace do span ativo. ```php PHP theme={null} Appsignal::setNamespace("admin"); ``` Se você chamar este helper várias vezes dentro de um único trace, o AppSignal usará a chamada cujo span tenha o timestamp mais novo. [Leia mais sobre como a instrumentação personalizada funciona em PHP][php custom instrumentation]. [php custom instrumentation]: /php/instrumentation.html ### Python Em aplicativos Python, o AppSignal funciona com o OpenTelemetry, que usa spans para rastrear metadados, como a qual namespace um span pertence. Use a função helper `set_namespace` como no exemplo abaixo para definir o namespace para o trace do span ativo. ```python Python theme={null} from appsignal import set_namespace set_namespace("custom-namespace") ``` [Leia mais sobre como os spans funcionam em Python](/python/instrumentation/instrumentation). ### JavaScript de front-end Em aplicativos JavaScript de front-end, o AppSignal funciona com spans para rastrear metadados, como o namespace de um span. Diferente de Ruby, Node.js, PHP e Python, a API JavaScript de front-end não possui um helper global `setNamespace` / `set_namespace`. Em vez disso, como Elixir, Go e Java, você define o namespace diretamente em um span. Ao criar este span, chame `setNamespace` com um valor `String` do nome do namespace desejado, conforme demonstrado no exemplo abaixo: ```javascript JavaScript theme={null} const span = appsignal.createSpan(); span.setNamespace("admin"); // um namespace personalizado para este span (padrão é `frontend`) ``` [Leia mais sobre como os spans funcionam em JavaScript de front-end](/front-end/span). ### Go Em aplicativos Go, o AppSignal funciona com o OpenTelemetry, que usa spans para rastrear metadados, como a qual namespace um span pertence. Em qualquer span no trace, defina um atributo `appsignal.namespace` com um valor String do novo namespace. ```go Go theme={null} span.SetAttributes(attribute.String("appsignal.namespace", "admin")) ``` Consulte a [documentação de instrumentação personalizada Go][go custom instrumentation] sobre como buscar um span ou criar um novo. Se vários atributos com o atributo `appsignal.namespace` forem encontrados, o span com o timestamp mais novo prevalece. [Leia mais sobre como a instrumentação personalizada funciona em Go][go custom instrumentation]. [go custom instrumentation]: /go/custom-instrumentation.html ### Java Em aplicativos Java, o AppSignal funciona com o OpenTelemetry, que usa spans para rastrear metadados, como a qual namespace um span pertence. Em qualquer span no trace, defina um atributo `appsignal.namespace` com um valor String do novo namespace. ```java Java theme={null} span.setAttribute("appsignal.namespace", "admin"); ``` Consulte a [documentação de instrumentação personalizada Java][java custom instrumentation] sobre como buscar um span ou criar um novo. Se vários atributos com o atributo `appsignal.namespace` forem encontrados, o span com o timestamp mais novo prevalece. [Leia mais sobre como a instrumentação personalizada funciona em Java][java custom instrumentation]. [java custom instrumentation]: /java/custom-instrumentation.html ## Deploy Quando seu aplicativo estiver configurado com seus novos helpers de namespace, faça o commit das alterações e o deploy do app. Quando o app iniciar/reiniciar, o AppSignal reportará ações sob seu novo namespace 🥳! Os dados de deploys antigos permanecerão agrupados pelo seu namespace original. Apenas ações recém-reportadas serão agrupadas pelos seus novos namespaces. Os namespaces não estão sendo reportados corretamente? Não entre em pânico, [entre em contato][contact] e nós o ajudaremos! ## Leitura adicional * [Filtrando dados do app][filtering] * [Namespaces][namespaces] * [Ignorando namespaces][ignoring namespaces] [contact]: mailto:support@appsignal.com [elixir helper]: https://hexdocs.pm/appsignal/Appsignal.Span.html?#set_namespace/2 [elixir namespace_decorator]: /elixir/instrumentation/instrumentation.html#decorator-namespaces [elixir namespace_helper]: /elixir/instrumentation/instrumentation.html#helper-namespaces [filtering]: /guides/filter-data/ [ignoring namespaces]: /guides/filter-data/ignore-namespaces.html [namespaces]: /application/namespaces.html [ruby helper]: https://gemdocs.org/gems/appsignal/3.4.0/Appsignal/Transaction.html#initialize-instance_method [tagging]: /guides/tagging.html