Mapa de serviços
Veja quem chama quem e onde a lentidão começa, montado a partir dos traces.
Logs, traces, métricas e alertas da sua aplicação em um só painel, em português. Instale o SDK em minutos e pague um preço fixo em reais, com usuários ilimitados.
Produto
A Home responde se está tudo bem. Logs, traces e métricas mostram o porquê, ligados pelo mesmo trace_id.
TypeError: reading 'cep'POST /pedidos · 14TimeoutError gateway-pixPOST /pix · 3JWT expiredGET /me · 41gateway-pix1,8 sviacep272 mssendgrid91 msSpan selecionado
validarEnderecoTelegram · #plantao
api-pedidos · 3,1% nos últimos 5 min
Começou 2 min depois do deploy v1.42.0
Abrir no Mensuro →api-pedidos · 0,3%
SDKs para as linguagens e os frameworks que o seu time já usa. Sua stack não está aqui? Peça o SDK de integração e a gente entrega.
// A primeira linha liga traces, logs e métricas
import '@mensuro/nest/register';
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
async function bootstrap() {
const app = await NestFactory.create(AppModule);
await app.listen(3000);
}
bootstrap();import { Module } from '@nestjs/common';
import { MensuroModule } from '@mensuro/nest';
import { PedidosModule } from './pedidos/pedidos.module';
@Module({
imports: [
MensuroModule.forRoot(),
PedidosModule,
],
})
export class AppModule {}import { Injectable, Logger } from '@nestjs/common';
@Injectable()
export class PedidosService {
private readonly logger = new Logger(PedidosService.name);
async criar(dto: CriarPedidoDto) {
// Cada log já sai com o trace_id da requisição
this.logger.log(`pedido criado para ${dto.clienteId}`);
// A chamada ao gateway vira um span com a latência do terceiro
return this.gateway.cobrarPix(dto);
}
}npm i @mensuro/nest
# .env
MENSURO_API_KEY=mns_live_8f2c41d9e7
OTEL_SERVICE_NAME=api-pedidos
NODE_ENV=production// node --require @mensuro/node/register server.js
import express from 'express';
import { mensuro } from '@mensuro/node';
const app = express();
app.use(mensuro.express());
app.post('/pedidos', async (req, res) => {
mensuro.log.info('pedido recebido', { cliente: req.body.clienteId });
const pedido = await pedidos.criar(req.body);
res.status(201).json(pedido);
});
app.listen(3000);import Fastify from 'fastify';
import { mensuroFastify } from '@mensuro/node/fastify';
const app = Fastify({ logger: true });
await app.register(mensuroFastify, {
service: 'api-catalogo',
});
// Os logs do Fastify já saem com o trace_id
app.get('/produtos/:id', async (req) => {
req.log.info({ id: req.params.id }, 'buscando produto');
return catalogo.buscar(req.params.id);
});
await app.listen({ port: 3000 });// instrumentation.ts, na raiz do projeto
export async function register() {
if (process.env.NEXT_RUNTIME === 'nodejs') {
const { init } = await import('@mensuro/node');
init({ service: 'loja-web' });
}
}
// app/api/checkout/route.ts
import { mensuro } from '@mensuro/node';
export async function POST(req: Request) {
mensuro.log.info('checkout iniciado');
return Response.json(await checkout(await req.json()));
}import { withMensuro } from '@mensuro/lambda';
// Envia os dados antes de a função congelar
export const handler = withMensuro(async (event) => {
const nota = JSON.parse(event.body);
console.info('emitindo nota', { numero: nota.numero });
await emissor.enviar(nota);
return { statusCode: 202 };
});// api/webhook.ts
import { withMensuro } from '@mensuro/vercel';
export default withMensuro(async (req, res) => {
const evento = req.body;
// Logs, duração e erros de cada invocação
console.log('webhook recebido', evento.tipo);
await filas.publicar(evento);
res.status(200).end();
});import { instrument } from '@mensuro/workers';
export default instrument({
async fetch(request, env, ctx) {
const url = new URL(request.url);
const resposta = await fetch(env.ORIGEM + url.pathname);
return resposta;
},
}, (env) => ({
apiKey: env.MENSURO_API_KEY,
service: 'borda-cdn',
}));# Gemfile
gem 'mensuro'
# config/initializers/mensuro.rb
Mensuro.configure do |config|
config.api_key = ENV['MENSURO_API_KEY']
config.service = 'erp-rails'
end
# app/controllers/pedidos_controller.rb
class PedidosController < ApplicationController
def create
Rails.logger.info "pedido #{params[:id]} recebido"
render json: Pedido.create!(pedido_params), status: :created
end
endrequire 'sinatra'
require 'mensuro'
Mensuro.configure { |c| c.service = 'api-agenda' }
use Mensuro::Rack
post '/agendamentos' do
Mensuro.logger.info 'novo agendamento'
Agenda.marcar(JSON.parse(request.body.read))
status 201
end# pip install mensuro[fastapi]
from fastapi import FastAPI
import logging
import mensuro
mensuro.init(service="api-cobranca")
app = FastAPI()
mensuro.instrument_fastapi(app)
log = logging.getLogger(__name__)
@app.post("/boletos")
async def emitir(boleto: Boleto):
log.info("emitindo boleto", extra={"valor": boleto.valor})
return await banco.emitir(boleto)# settings.py
INSTALLED_APPS = [
# ...
"mensuro.django",
]
MIDDLEWARE = [
"mensuro.django.MensuroMiddleware",
# ...
]
MENSURO = {
"API_KEY": env("MENSURO_API_KEY"),
"SERVICE": "portal-clinica",
}from flask import Flask
import mensuro
mensuro.init(service="api-estoque")
app = Flask(__name__)
mensuro.instrument_flask(app)
@app.get("/estoque/<sku>")
def saldo(sku):
app.logger.info("consulta de saldo", extra={"sku": sku})
return estoque.saldo(sku)// composer require mensuro/laravel
// php artisan mensuro:install
// .env
// MENSURO_API_KEY=mns_live_8f2c41d9e7
// MENSURO_SERVICE=painel-laravel
use Illuminate\Support\Facades\Log;
class PedidoController extends Controller
{
public function store(PedidoRequest $request)
{
Log::info('pedido recebido', ['cliente' => $request->cliente_id]);
return Pedido::create($request->validated());
}
}// config/bundles.php
return [
// ...
Mensuro\Symfony\MensuroBundle::class => ['all' => true],
];
// config/packages/mensuro.yaml
// mensuro:
// api_key: '%env(MENSURO_API_KEY)%'
// service: 'api-reservas'
// O logger do Monolog já sai com o trace_id
$this->logger->info('reserva confirmada', ['id' => $reserva->getId()]);npm i -g @mensuro/cli
# Entra na sua conta e escolhe o projeto
mensuro login
mensuro projeto usar loja-aurora --env production
# Marca o deploy para comparar antes e depois
mensuro deploy marcar --servico api-pedidos --versao v1.42.0
# Acompanha os erros ao vivo, direto do terminal
mensuro logs --servico api-pedidos --nivel error --seguir# .github/workflows/deploy.yml
- name: Marcar deploy no Mensuro
run: npx @mensuro/cli deploy marcar \
--servico api-pedidos \
--versao ${{ github.sha }}
env:
MENSURO_API_KEY: ${{ secrets.MENSURO_API_KEY }}package main
import (
"log/slog"
"net/http"
"github.com/mensuro/mensuro-go"
)
func main() {
stop := mensuro.Start(mensuro.Config{Service: "api-frete"})
defer stop()
mux := http.NewServeMux()
mux.HandleFunc("POST /cotacoes", func(w http.ResponseWriter, r *http.Request) {
slog.InfoContext(r.Context(), "cotando frete")
cotar(w, r)
})
http.ListenAndServe(":8080", mensuro.Handler(mux))
}import (
"github.com/gin-gonic/gin"
"github.com/mensuro/mensuro-go"
mgin "github.com/mensuro/mensuro-go/gin"
)
func main() {
defer mensuro.Start(mensuro.Config{Service: "api-rastreio"})()
r := gin.New()
r.Use(mgin.Middleware())
r.GET("/rastreio/:codigo", rastrear)
r.Run(":8080")
}use axum::{routing::post, Router};
use tracing::info;
#[tokio::main]
async fn main() {
let _guard = mensuro::init("api-pagamentos");
let app = Router::new()
.route("/pix", post(cobrar))
.layer(mensuro::axum::layer());
let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await.unwrap();
axum::serve(listener, app).await.unwrap();
}
async fn cobrar() -> &'static str {
info!("cobrança pix criada");
"ok"
}use actix_web::{get, App, HttpServer, Responder};
#[get("/saude")]
async fn saude() -> impl Responder { "ok" }
#[actix_web::main]
async fn main() -> std::io::Result<()> {
let _guard = mensuro::init("api-notas");
HttpServer::new(|| App::new().wrap(mensuro::actix::Middleware).service(saude))
.bind(("0.0.0.0", 8080))?
.run()
.await
}// build.gradle
// implementation 'br.com.mensuro:mensuro-spring-boot-starter:1.4.0'
// application.yml
// mensuro:
// api-key: ${MENSURO_API_KEY}
// service: api-contratos
@RestController
@RequestMapping("/contratos")
class ContratoController {
private static final Logger log = LoggerFactory.getLogger(ContratoController.class);
@PostMapping
Contrato assinar(@RequestBody Contrato contrato) {
log.info("assinando contrato {}", contrato.id());
return contratos.assinar(contrato);
}
}// pom.xml: br.com.mensuro:mensuro-quarkus
// application.properties
// mensuro.api-key=${MENSURO_API_KEY}
// mensuro.service=api-sinistros
@Path("/sinistros")
public class SinistroResource {
@Inject Logger log;
@POST
public Sinistro abrir(Sinistro sinistro) {
log.infof("sinistro aberto: %s", sinistro.protocolo());
return service.abrir(sinistro);
}
}# mix.exs
defp deps do
[{:mensuro, "~> 1.2"}]
end
# config/runtime.exs
config :mensuro,
api_key: System.fetch_env!("MENSURO_API_KEY"),
service: "chat-atendimento"
# lib/app/application.ex
def start(_type, _args) do
Mensuro.Phoenix.setup()
Mensuro.Ecto.setup([:app, :repo])
# ...
end// dotnet add package Mensuro.AspNetCore
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddMensuro(options =>
{
options.Service = "api-faturamento";
});
var app = builder.Build();
app.MapPost("/faturas", (Fatura fatura, ILogger<Program> log) =>
{
log.LogInformation("fatura {Numero} emitida", fatura.Numero);
return Results.Created($"/faturas/{fatura.Numero}", fatura);
});
app.Run();curl -X POST https://ingest.mensuro.com.br/v1/logs \
-H "Authorization: Bearer $MENSURO_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"service": "rotina-noturna",
"level": "error",
"message": "falha ao conciliar extrato",
"attributes": { "banco": "itau", "tentativa": 3 }
}'curl -X POST https://api.mensuro.com.br/v1/deploys \
-H "Authorization: Bearer $MENSURO_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"service": "api-pedidos",
"version": "v1.42.0",
"environment": "production"
}'Precisa de outra linguagem? Peça o SDK de integração
Recursos
Veja quem chama quem e onde a lentidão começa, montado a partir dos traces.
O erro que surgiu depois do deploy aparece sozinho, com contagem e rota.
TypeError: Cannot read properties of undefined (reading 'cep')Mostre ao seu cliente que o sistema está de pé, com o seu domínio.
Slack, Telegram, e-mail ou webhook, com botão de teste para conferir antes de precisar.
Saiba se a lentidão é sua ou da API de terceiros que você chama.
Marque a versão pelo SDK, pela CLI ou pelo CI. Se a latência ou os erros pioram, o alerta de deploy com piora avisa sem você escrever consulta.
Convide quantas pessoas quiser, com papéis de dono, admin e membro. Gere e revogue chaves sem derrubar nada. Exporte ou apague os dados quando precisar.
mns_live_••••8f2capi-pedidosativamns_live_••••a91eapi-pagamentosativamns_live_••••03bdantigarevogadaQuem usa
Abre o erro, segue o trace_id e lê o log da requisição que quebrou, sem SSH no servidor.
Recebe o alerta no canal do plantão e decide se faz rollback olhando um painel só.
Um projeto por cliente, uma página de status pública para cada um e um relatório que se defende sozinho.
Sem montar nada
Sem infraestrutura para manter
Armazenamento, retenção, backups e escala ficam por nossa conta. A sua aplicação só envia.
O envio acontece em segundo plano. A resposta ao seu usuário não espera o Mensuro.
Os dados ficam na fila em disco e são reenviados com espera crescente, de 1 a 60 segundos.
Ligue ou desligue logs, traces e grupos de métricas por variável de ambiente.
Cada cliente tem os dados separados, com TLS no envio e backup com restauração testada.
Uso e plano
O preço é fixo por faixa de GB ingeridos. A tela Uso e plano mostra quanto cada sinal consome no ciclo e avisa em 80% e em 100% da cota.
Ver os planosPlanos
R$0/mês
para sempre
2 GB por mês
Excedente opcional: R$5 por GB
R$149/mês
cobrado por mês
30 GB por mês
Excedente opcional: R$4 por GB
R$399/mês
cobrado por mês
150 GB por mês
Excedente opcional: R$3 por GB
a partir de R$990/mês
cobrado por mês
500 GB ou mais por mês
Excedente opcional: R$2 por GB
Dúvidas
Não achou a sua? Fale com a gente em contato@mensuro.com.br ou no WhatsApp.
Não. Em NestJS é um import no main.ts, o módulo no AppModule e a chave do projeto numa variável de ambiente. Nas outras linguagens, o SDK do Mensuro entra como middleware ou pacote de inicialização, em poucos minutos.
Funciona com qualquer linguagem. Já temos SDK para Node.js, NestJS, Python, PHP, Ruby, Go, Java, .NET, Elixir, Rust e serverless. Se a sua stack não estiver na lista, peça o SDK de integração pelo formulário ou pelo WhatsApp.
O SDK trabalha fora do caminho da requisição: junta os dados em lote, comprime e envia a cada 5 segundos. Se a rede cair, guarda tudo numa fila em disco e reenvia depois, sem travar o seu código.
A soma dos dados que a sua aplicação envia no mês: logs, traces e métricas. A tela Uso e plano mostra o consumo do ciclo, e você recebe aviso ao chegar em 80% e em 100% da cota.
Nada é cobrado de surpresa. Por padrão, quando a cota do mês acaba, o Mensuro para de receber dados novos até o mês virar, e o que já foi guardado continua lá. Se preferir não parar, o dono da organização liga o excedente em Uso e plano e paga só os GB além da cota: R$5 no Grátis, R$4 no Starter, R$3 no Growth e R$2 no Business. Também dá para mudar de plano na hora.
No dia 1 de cada mês, à meia-noite de Brasília. Um GB aqui é 1 bilhão de bytes, e a tela Uso e plano mostra o consumo de cada sinal no mês.
Em servidores no Brasil, isolados por organização. Você pode exportar os dados ou apagar a conta quando quiser, como pede a LGPD.
Não. Todos os planos têm usuários ilimitados. O preço é fixo por mês, em reais, pago por Pix ou cartão, com nota fiscal.
O Mensuro agrupa os erros novos e liga cada um ao log e ao trace da requisição que falhou. Se você usa o Sentry só para exceções, pode manter os dois.
Preencha o formulário no fim da página ou chame no WhatsApp. Respondemos com o acesso, a chave do projeto e ajuda para instalar o SDK.
Contratar
Conte um pouco da sua aplicação. Respondemos com o acesso, a chave do projeto e ajuda para instalar o SDK na sua stack.