Monoscope

https://monoscope.tech/docs
Admin
Monoscope is an API monitoring and observability platform that enables developers to track metrics,...
Tokens:77,549
Snippets:959
Trust Score:6.4
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install monoscope-go/gorilla SDK

Source: https://monoscope.tech/docs/sdks/golang/gorillamux

Install the monoscope gorilla mux SDK using the `go get` command.

```sh
go get github.com/monoscope-tech/monoscope-go/gorilla

```

--------------------------------

### Install Monoscope Go Fiber SDK

Source: https://monoscope.tech/docs/sdks/golang/fiber

Install the Monoscope fiber SDK using the `go get` command. This command fetches and installs the necessary package.

```sh
go get github.com/monoscope-tech/monoscope-go/fiber
```

--------------------------------

### Install Monoscope Go SDK

Source: https://monoscope.tech/docs/sdks/golang/native

Use the go get command to add the native Monoscope SDK to your project.

```sh
go get github.com/monoscope-tech/monoscope-go/native
```

--------------------------------

### Install Monoscope Gin SDK

Source: https://monoscope.tech/docs/sdks/golang/gin

Use the go get command to add the Monoscope Gin package to your project.

```sh
go get github.com/monoscope-tech/monoscope-go/gin
```

--------------------------------

### Install Monoscope Go Chi SDK

Source: https://monoscope.tech/docs/sdks/golang/chi

Install the Monoscope chi SDK using the `go get` command. This command fetches and installs the necessary package for your project.

```sh
go get github.com/monoscope-tech/monoscope-go/chi

```

--------------------------------

### Fetch Todo items with GET

Source: https://monoscope.tech/docs/dashboard/dashboard-pages/api-tests

Basic GET request example for retrieving todo items.

```yaml
- title: Fetches Todo items - GET
  GET: /todos/
```

--------------------------------

### Go Native SDK Installation

Source: https://monoscope.tech/docs/sdks/golang/native

Install the Monoscope native Go SDK using the go get command.

```APIDOC
## Go Native SDK Installation

Install the Monoscope native Go SDK using the following command `go get` command:

```sh
go get github.com/monoscope-tech/monoscope-go/native
```
```

--------------------------------

### Install Monoscope Echo SDK

Source: https://monoscope.tech/docs/sdks/golang/echo

Use the go get command to add the Monoscope Echo package to your project.

```sh
go get github.com/monoscope-tech/monoscope-go/echo
```

--------------------------------

### Usage Example

Source: https://monoscope.tech/docs/sdks/golang/native

Example of configuring OpenTelemetry SDK and Monoscope middleware.

```APIDOC
## Usage

After setting up the environment variables, you can configure the OpenTelemetry SDK and Monoscope middleware like so:

```go
package main

import (
	"log"

	monoscope "github.com/monoscope-tech/monoscope-go/native"
  _ "github.com/joho/godotenv/autoload" // autoload .env file for otel configuration

)

func main() {
  // configure openTelemetry
	shutdown, err := monoscope.ConfigureOpenTelemetry()
	if err != nil {
		log.Printf("error configuring openTelemetry: %v", err)
	}
	defer shutdown()

	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("Hello, World!"))
	})
  // configure monoscope middleware
	nativeMiddleware := monoscope.Middleware(monoscope.Config{
		RedactHeaders:       []string{"Authorization", "X-Api-Key"},
		RedactRequestBody:   []string{"password", "credit_card"},
		RedactResponseBody:  []string{"password", "credit_card"},
	})
	// Wrap handler with middleware for monitoring requests and reporting errors
	http.Handle("/", nativeMiddleware(handler))
	if err := http.ListenAndServe(":8000", nil); err != nil {
		log.Fatal(err)
	}
}
```
```

--------------------------------

### Install Monoscope FastAPI SDK

Source: https://monoscope.tech/docs/sdks/python/fastapi

Install the required packages and bootstrap OpenTelemetry instrumentation.

```sh
pip install monoscope-fastapi opentelemetry-distro opentelemetry-exporter-otlp
opentelemetry-bootstrap -a install
```

--------------------------------

### Start and Enable Systemd Service

Source: https://monoscope.tech/docs/sdks/infrastructure/linux

Reload systemd, enable the OpenTelemetry Collector service to start on boot, and start the service.

```bash
sudo systemctl daemon-reload
sudo systemctl enable otel-collector
sudo systemctl start otel-collector
```

--------------------------------

### Install Monoscope Browser SDK

Source: https://monoscope.tech/docs/sdks/Javascript/reactjs

Install the required package via npm.

```bash
npm install @monoscopetech/browser
```

--------------------------------

### Start Instrumented Server

Source: https://monoscope.tech/docs/sdks/python/flask

Use the opentelemetry-instrument command to start the application with automatic instrumentation.

```sh
opentelemetry-instrument flask run --app app
```

```sh
opentelemetry-instrument gunicorn server:app
```

--------------------------------

### Install Monoscope Pyramid SDK and OpenTelemetry

Source: https://monoscope.tech/docs/sdks/python/pyramid

Installs the monoscope-pyramid SDK along with necessary OpenTelemetry packages. Ensure you have Python and pip installed.

```sh
pip install monoscope-pyramid opentelemetry-distro opentelemetry-exporter-otlp
opentelemetry-bootstrap -a install
```

--------------------------------

### Install Node.js Instrumentation Packages

Source: https://monoscope.tech/docs/sdks/databases/mysql

Install the necessary OpenTelemetry SDK and auto-instrumentation packages via npm.

```bash
npm install @opentelemetry/sdk-node @opentelemetry/auto-instrumentations-node @opentelemetry/exporter-trace-otlp-proto
```

--------------------------------

### Install Monoscope Flask SDK and Dependencies

Source: https://monoscope.tech/docs/sdks/python/flask

Run these commands to install the necessary packages and bootstrap OpenTelemetry instrumentation.

```sh
pip install monoscope-flask opentelemetry-distro opentelemetry-exporter-otlp
opentelemetry-bootstrap -a install
```

--------------------------------

### Install tcpdump

Source: https://monoscope.tech/docs/sdks/infrastructure/linux

Installs the tcpdump utility for network traffic capture.

```bash
sudo apt-get update && sudo apt-get install -y tcpdump
```

--------------------------------

### Install Monoscope Express SDK

Source: https://monoscope.tech/docs/sdks/nodejs/expressjs

Install the necessary Monoscope and OpenTelemetry packages using npm.

```sh
npm install --save @monoscopetech/express @opentelemetry/api @opentelemetry/auto-instrumentations-node
```

--------------------------------

### Install Ruby Gems

Source: https://monoscope.tech/docs/sdks/opentelemetry

Install the necessary OpenTelemetry gems via command line or Gemfile.

```bash
gem install opentelemetry-sdk opentelemetry-exporter-otlp opentelemetry-instrumentation-all
```

```ruby
gem 'opentelemetry-sdk'
gem 'opentelemetry-exporter-otlp'
gem 'opentelemetry-instrumentation-all'
```

--------------------------------

### Install OpenTelemetry Node.js SDK

Source: https://monoscope.tech/docs/sdks/nodejs/nestjs

Install the OpenTelemetry API, SDK, and auto-instrumentation tools for Node.js. Use npm or yarn.

```sh
npm install --save @opentelemetry/api \
    @opentelemetry/auto-instrumentations-node

# Or

yarn add @opentelemetry/api @opentelemetry/auto-instrumentations-node
```

--------------------------------

### Install OpenTelemetry PHP extension

Source: https://monoscope.tech/docs/sdks/php/slim

Install the required PHP extension for OpenTelemetry support.

```sh
pecl install opentelemetry
```

--------------------------------

### Install OpenTelemetry Auto-Instrumentation for .NET

Source: https://monoscope.tech/docs/sdks/dotnet/dotnetcore

Installs the OpenTelemetry auto-instrumentation packages for .NET. Ensure you have `curl` and `chmod` available.

```sh
# Download the bash script
curl -sSfL https://github.com/open-telemetry/opentelemetry-dotnet-instrumentation/releases/latest/download/otel-dotnet-auto-install.sh -O

# Install core files
sh ./otel-dotnet-auto-install.sh

# Enable execution for the instrumentation script
chmod +x $HOME/.otel-dotnet-auto/instrument.sh

# Setup the instrumentation for the current shell session
. $HOME/.otel-dotnet-auto/instrument.sh

```

--------------------------------

### Install and run telemetrygen on Linux

Source: https://monoscope.tech/docs/dashboard/dashboard-pages/get-started

Download the binary, set permissions, and execute to send test traces.

```bash
# Download and install
curl -LO https://github.com/open-telemetry/opentelemetry-collector-contrib/releases/latest/download/telemetrygen_linux_amd64
chmod +x telemetrygen_linux_amd64
sudo mv telemetrygen_linux_amd64 /usr/local/bin/telemetrygen

# Send test data
telemetrygen traces --otlp-insecure \
  --otlp-endpoint otel.monoscope.tech:4317 \
  --otlp-header="x-api-key=YOUR_API_KEY" \
  --traces 10 --rate 2
```

--------------------------------

### Install Monoscope Fastify SDK

Source: https://monoscope.tech/docs/sdks/nodejs/fastifyjs

Install the required Monoscope Fastify package along with OpenTelemetry dependencies.

```sh
npm install --save @monoscopetech/fastify @opentelemetry/api @opentelemetry/auto-instrumentations-node
```

--------------------------------

### Install Monoscope Symfony SDK

Source: https://monoscope.tech/docs/sdks/php/symfony

Run this command to install the Monoscope SDK for your Symfony application.

```sh
composer require monoscope/monoscope-symfony
```

--------------------------------

### Install Slim SDK and OpenTelemetry dependencies

Source: https://monoscope.tech/docs/sdks/php/slim

Use Composer to install the necessary OpenTelemetry and Monoscope packages for your Slim application.

```sh
composer require \
    open-telemetry/sdk \
    open-telemetry/exporter-otlp \
    open-telemetry/opentelemetry-auto-slim \
    open-telemetry/opentelemetry-auto-psr18 \
    monoscope/monoscope-slim
```

--------------------------------

### Install Monoscope Next.js SDK and OpenTelemetry

Source: https://monoscope.tech/docs/sdks/nodejs/nextjs

Installs the necessary Monoscope and OpenTelemetry packages for Next.js applications. Ensure you have Node.js and npm/yarn installed.

```sh
npm install --save @monoscopetech/next @opentelemetry/api @vercel/otel

```

--------------------------------

### Install and run telemetrygen on macOS

Source: https://monoscope.tech/docs/dashboard/dashboard-pages/get-started

Install via Homebrew and send test traces to the Monoscope endpoint.

```bash
# Install with Homebrew
brew install telemetrygen

# Send test data
telemetrygen traces --otlp-insecure \
  --otlp-endpoint otel.monoscope.tech:4317 \
  --otlp-header="x-api-key=YOUR_API_KEY" \
  --traces 10 --rate 2
```

--------------------------------

### Install telemetrygen on Linux

Source: https://monoscope.tech/docs/onboarding

Installs the telemetrygen tool on Linux by downloading the binary. Make sure the downloaded binary is executable and placed in your system's PATH.

```bash
# Download the binary
curl -LO https://github.com/open-telemetry/opentelemetry-collector-contrib/releases/latest/download/telemetrygen_linux_amd64
chmod +x telemetrygen_linux_amd64
sudo mv telemetrygen_linux_amd64 /usr/local/bin/telemetrygen
```

--------------------------------

### GET /monitors

Source: https://monoscope.tech/docs/api-reference/getting-started

List all configured monitors.

```APIDOC
## GET /monitors

### Description
Retrieve a list of all monitors configured in the system.

### Method
GET

### Endpoint
/monitors
```

--------------------------------

### GET /monitors

Source: https://monoscope.tech/docs/api-reference/getting-started/introduction

List all configured monitors.

```APIDOC
## GET /monitors

### Description
Retrieve a list of all monitors currently configured in the system.

### Method
GET

### Endpoint
https://api.monoscope.tech/monitors
```

--------------------------------

### Install Monoscope Adonis SDK and OpenTelemetry

Source: https://monoscope.tech/docs/sdks/nodejs/adonisjs

Install the necessary packages for Monoscope integration and OpenTelemetry auto-instrumentation.

```sh
npm install --save @monoscopetech/adonis @opentelemetry/api  @opentelemetry/auto-instrumentations-node

```

--------------------------------

### Install and run telemetrygen on Windows

Source: https://monoscope.tech/docs/dashboard/dashboard-pages/get-started

Download the executable via PowerShell and run it to send test traces.

```powershell
# Download in PowerShell
Invoke-WebRequest -Uri https://github.com/open-telemetry/opentelemetry-collector-contrib/releases/latest/download/telemetrygen_windows_amd64.exe -OutFile telemetrygen.exe

# Send test data
.\telemetrygen.exe traces --otlp-insecure `
  --otlp-endpoint otel.monoscope.tech:4317 `
  --otlp-header="x-api-key=YOUR_API_KEY" `
  --traces 10 --rate 2
```

--------------------------------

### Install monoscope SDK for .NET

Source: https://monoscope.tech/docs/sdks/dotnet/dotnetcore

Installs the monoscope SDK package using the .NET CLI. This package provides middleware for monitoring requests and errors.

```sh
dotnet add package ApiToolkit.Net

```

--------------------------------

### Install Monoscope Django SDK and OpenTelemetry

Source: https://monoscope.tech/docs/sdks/python/django

Install the monoscope-django SDK along with necessary OpenTelemetry packages using pip. This command also bootstraps OpenTelemetry.

```sh
pip install monoscope-django opentelemetry-distro opentelemetry-exporter-otlp
opentelemetry-bootstrap -a install
```

--------------------------------

### Install telemetrygen on Windows

Source: https://monoscope.tech/docs/onboarding

Installs the telemetrygen tool on Windows by downloading the executable from PowerShell. The downloaded file will be named telemetrygen.exe.

```powershell
# Download from PowerShell
Invoke-WebRequest -Uri https://github.com/open-telemetry/opentelemetry-collector-contrib/releases/latest/download/telemetrygen_windows_amd64.exe -OutFile telemetrygen.exe
```

--------------------------------

### Start Instrumented Server

Source: https://monoscope.tech/docs/sdks/python/fastapi

Commands to run the FastAPI application with OpenTelemetry instrumentation using Uvicorn or Gunicorn.

```sh
opentelemetry-instrument uvicorn main:app
```

```sh
opentelemetry-instrument gunicorn -c gunicorn.conf.py main:app
```

--------------------------------

### Install Monoscope Laravel SDK

Source: https://monoscope.tech/docs/sdks/php/laravel

Install the Monoscope Laravel SDK and required OpenTelemetry packages using Composer. Ensure you have the necessary OpenTelemetry PHP extension configured.

```sh
composer require \
    open-telemetry/sdk \
    open-telemetry/exporter-otlp \
    monoscope/laravel

```

--------------------------------

### GET /monitors

Source: https://monoscope.tech/docs/api-reference

List all monitors associated with your projects.

```APIDOC
## GET /monitors

### Description
List all configured monitors.

### Method
GET

### Endpoint
https://api.monoscope.tech/monitors
```

--------------------------------

### Configure Node.js Auto-Instrumentation

Source: https://monoscope.tech/docs/sdks/databases/mongodb

Installs necessary OpenTelemetry packages and initializes the NodeSDK to automatically instrument MongoDB.

```bash
npm install @opentelemetry/sdk-node @opentelemetry/auto-instrumentations-node @opentelemetry/exporter-trace-otlp-proto
```

```javascript
const { NodeSDK } = require('@opentelemetry/sdk-node');
const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-proto');

const sdk = new NodeSDK({
  traceExporter: new OTLPTraceExporter({
    url: 'http://otelcol.monoscope.tech:4317/v1/traces',
  }),
  instrumentations: [getNodeAutoInstrumentations()],
  resourceAttributes: {
    'x-api-key': 'YOUR_API_KEY',
    'service.name': 'mongodb-service',
  },
});

// Initialize the SDK before importing MongoDB
sdk.start();

// Now it's safe to import and use MongoDB
const { MongoClient } = require('mongodb');
```

--------------------------------

### Define API Test Scenarios in YAML

Source: https://monoscope.tech/docs/dashboard/dashboard-pages/api-tests

Example of a YAML test file containing multiple stages for GET, DELETE, and POST requests with assertions and exports.

```yaml
---
- title: fetches TODO items - GET
  GET: /todos/
  asserts:
    - ok: $.resp.status == 200
    - array: $.resp.json
  exports:
    todoItem: $.resp.json[0]._id

- title: deletes TODO items - DELETE
  DELETE: /todos/$.stages[0].todoItem
  asserts:
    - empty: $.resp.json.todos
    - string: $.resp.json

- title: Adds Todo item - POST
  POST: /todos/
  json:
    task: "run tests"
  asserts:
    - ok: $.resp.status == 200
    - ok: $.resp.json.task == "run tests"
    - ok: $.resp.json.completed
```

--------------------------------

### Install OpenTelemetry Operator

Source: https://monoscope.tech/docs/sdks/infrastructure/kubernetes

Installs the OpenTelemetry Operator. Ensure cert-manager is installed first. Use a pinned release tag for production.

```bash
kubectl apply -f https://github.com/open-telemetry/opentelemetry-operator/releases/latest/download/opentelemetry-operator.yaml
```

--------------------------------

### Initialize Fastify Server and Report Errors

Source: https://monoscope.tech/docs/sdks/nodejs/fastifyjs

Set up the Fastify server with Monoscope and demonstrate manual error reporting. Ensure OpenTelemetry is registered early for comprehensive monitoring.

```typescript
import "dotenv/config";
import "@opentelemetry/auto-instrumentations-node/register"; // IMPORTANT: Do this as early as possible in your server
import fastify from "fastify";
import { Monoscope, reportError } from "@monoscopetech/fastify";
import axios from "axios";

const fastifyServer = fastify({});
const monoscopeClient = Monoscope.NewClient({
  fastify: fastifyServer,
});
monoscopeClient.initializeHooks();

fastifyServer.get("/", async (request, reply) => {
  try {
    throw new Error("Something went wrong");
    return { message: "Hello World" };
  } catch (error) {
    // Manually report the error to Monoscope
    reportError(error);
    return { message: "Something went wrong" };
  }
});
fastifyServer.listen({ port: 3000 });

```

--------------------------------

### All Environment Variables

Source: https://monoscope.tech/docs/sdks/golang/native

List of all environment variables required to enable the SDK.

```APIDOC
### All Environment Variables

Set the following environment variables in your application to enable the SDK:

Variable Name | Description | Required | Example  
---|---|---|---
`OTEL_RESOURCE_ATTRIBUTES` | Monoscope project key (`x-api-key=<YOUR_API_KEY>`) | Yes | `x-api-key=my-api-key`  
`OTEL_SERVICE_NAME` | The name of the service being monitored | No | `example-chi-server`  
`OTEL_SERVICE_VERSION` | The version of your application or service | No | `0.0.1`  
`OTEL_EXPORTER_OTLP_ENDPOINT` | The grpc endpoint for the OpenTelemetry collector. | No | `otelcol.monoscope.tech:4317`  
`OTEL_TRACES_ENABLED` | Enable or disable tracing | No | `true`  
`OTEL_METRICS_ENABLED` | Enable or disable metrics | No | `true`  
`OTEL_LOG_LEVEL` | The log level for the SDK (Set to debug to enable debug logs) | No | `info`  
`OTEL_EXPORTER_OTLP_METRICS_PERIOD` | The period at which metrics are exported. | No | `30s`  
`OTEL_PROPAGATORS` | The propagators to use for tracing. | No | `tracecontext,baggage`  
```

--------------------------------

### Start Docker Collector

Source: https://monoscope.tech/docs/sdks/infrastructure/linux

Start the OpenTelemetry Collector service in detached mode using Docker Compose.

```bash
docker-compose up -d
```

--------------------------------

### Helm Install for Monoscope Collector

Source: https://monoscope.tech/docs/sdks/infrastructure/kubernetes

Installs the OpenTelemetry Collector using Helm. Ensure values-cluster.yaml is configured correctly.

```bash
helm install monoscope-cluster open-telemetry/opentelemetry-collector \
  --values values-cluster.yaml
```

--------------------------------

### Install Monoscope Express Middleware

Source: https://monoscope.tech/docs/sdks/nodejs/nestjs

Install the Monoscope middleware package for NestJs applications using the Express adapter.

```sh
npm install --save @monoscopetech/express
```

--------------------------------

### Register Monoscope Middleware in Slim

Source: https://monoscope.tech/docs/sdks/php/slim

Initialize the MonoscopeMiddleware and add it to your Slim application instance.

```php
use Slim\Factory\AppFactory;
use Monoscope\MonoscopeMiddleware;

require __DIR__ . '/vendor/autoload.php';

$app = AppFactory::create();

// Initialize the Monoscope client
$monoscopeMiddleware = new MonoscopeMiddleware([
  'debug' => false,
  'tags' => ["environment: production", "region: us-east-1"],
  'captureRequestBody' => true,
  'serviceVersion' => "v2.0",
]);

$app->add($monoscopeMiddleware);
// END Initialize the Monoscope client

$app->get('/', function ($request, $response) {
  $response->getBody()->write('Hello, World!');
  return $response;
});

$app->run();
```

--------------------------------

### Initialize Monoscope Fastify Middleware

Source: https://monoscope.tech/docs/sdks/nodejs/fastifyjs

Setup the Monoscope client with a Fastify instance and optional Axios monitoring. Ensure the OpenTelemetry register module is imported before other application code.

```js
import "dotenv/config";
import "@opentelemetry/auto-instrumentations-node/register"; // IMPORTANT: Do this as early as possible in your server
import fastify from "fastify";
import { Monoscope } from "@monoscopetech/fastify";
import axios from "axios";

const fastifyServer = fastify({});
const monoscopeClient = Monoscope.NewClient({
  fastify: fastifyServer, // Required: The Fastify server instance
  monitorAxios: axios, // Optional: Use this to monitor Axios requests
});

monoscopeClient.initializeHooks();

fastifyServer.get("/", async (request, reply) => {
  const response = await axios.get("https://api.github.com/users/octocat");
  return response.data;
});

fastifyServer.listen({ port: 3000 });
```

--------------------------------

### List Monitors using cURL

Source: https://monoscope.tech/docs/api-reference/endpoints/listmonitors

Use this cURL command to list all monitors for a project. Ensure you replace YOUR_PROJECT_ID and YOUR_API_KEY with your actual credentials.

```bash
curl -X GET "https://api.monoscope.tech/api/v1/monitors?pid=YOUR_PROJECT_ID" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json"
```

--------------------------------

### Install Cert-Manager for Operator

Source: https://monoscope.tech/docs/sdks/infrastructure/kubernetes

Installs cert-manager, a prerequisite for the OpenTelemetry Operator's admission webhook. Use a pinned release tag for production.

```bash
kubectl apply -f https://github.com/cert-manager/cert-manager/releases/latest/download/cert-manager.yaml
```

--------------------------------

### Install Agent Collector with Helm

Source: https://monoscope.tech/docs/sdks/infrastructure/kubernetes

Install the Monoscope agent using the OpenTelemetry Collector Helm chart, referencing the custom `values-agent.yaml` configuration file.

```bash
helm install monoscope-agent open-telemetry/opentelemetry-collector \
  --values values-agent.yaml

```

--------------------------------

### Run Django Server with OpenTelemetry Instrumentation

Source: https://monoscope.tech/docs/sdks/python/django

Start your Django development server with OpenTelemetry instrumentation using the `opentelemetry-instrument` command. This ensures that traces and metrics are captured.

```sh
opentelemetry-instrument python3 manage.py runserver --noreload
```

--------------------------------

### Test Monoscope SDK Setup

Source: https://monoscope.tech/docs/sdks/Javascript/browser

Call the `test()` method to verify your Monoscope SDK setup. This sends a test span and logs the result to the console.

```javascript
const result = await monoscope.test();
console.log(result); // { success: true, message: "Test span sent successfully." }
```

--------------------------------

### Configure OpenTelemetry SDK and Monoscope Middleware in Go

Source: https://monoscope.tech/docs/sdks/golang/gorillamux

Configure the OpenTelemetry SDK and Monoscope middleware in a Go application. This includes setting up OpenTelemetry, registering Monoscope's middleware with data redaction rules, and starting the HTTP server.

```go
package main

import (
	"log"
	"net/http"

	monoscope "github.com/monoscope-tech/monoscope-go/gorilla"
	"github.com/gorilla/mux"
  _ "github.com/joho/godotenv/autoload" // autoload .env file for otel configuration

)

func main() {
	shutdown, err := monoscope.ConfigureOpenTelemetry()
	if err != nil {
		log.Printf("error configuring openTelemetry: %v", err)
	}
	defer shutdown()

	router := mux.NewRouter()
	// Register monoscope's middleware
	router.Use(monoscope.Middleware(
		monoscope.Config{
			RedactHeaders:       []string{"Authorization", "X-Api-Key"},
			RedactRequestBody:   []string{"password", "credit_card"},
			RedactResponseBody:  []string{"password", "credit_card"},
		}))

	router.HandleFunc("/test", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		w.Write([]byte("ok"))
	})
	http.Handle("/", router)
	http.ListenAndServe(":8000", router)

}

```

--------------------------------

### Initialize Ruby OpenTelemetry

Source: https://monoscope.tech/docs/sdks/opentelemetry

Configure the OpenTelemetry SDK at application startup to automatically use environment variables.

```ruby
require 'opentelemetry/sdk'
require 'opentelemetry/exporter/otlp'
require 'opentelemetry/instrumentation/all'

# Reads OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_SERVICE_NAME,
# OTEL_RESOURCE_ATTRIBUTES, and OTEL_EXPORTER_OTLP_PROTOCOL
# from environment variables automatically.
OpenTelemetry::SDK.configure do |c|
  c.use_all # Enables all available auto-instrumentation
end
```

--------------------------------

### Install OpenTelemetry PHP Extension

Source: https://monoscope.tech/docs/sdks/php/laravel

Install the OpenTelemetry PHP extension using PECL. This extension is required for sending traces, metrics, and logs to the Monoscope platform.

```sh
pecl install opentelemetry

```

--------------------------------

### Run Java Application with Agent

Source: https://monoscope.tech/docs/sdks/databases/mysql

Execute the Java application with the agent attached, specifying the service name, OTLP endpoint, and API key.

```bash
java -javaagent:path/to/opentelemetry-javaagent.jar \
     -Dotel.service.name=mysql-service \
     -Dotel.exporter.otlp.endpoint=http://otelcol.monoscope.tech:4317 \
     -Dotel.resource.attributes=x-api-key=YOUR_API_KEY \
     -jar your-application.jar
```

--------------------------------

### Install telemetrygen on macOS

Source: https://monoscope.tech/docs/onboarding

Installs the telemetrygen tool on macOS using Homebrew or by downloading the binary directly. Ensure the binary is executable and moved to a directory in your PATH.

```bash
# Using Homebrew
brew install telemetrygen

# Or download directly
curl -LO https://github.com/open-telemetry/opentelemetry-collector-contrib/releases/latest/download/telemetrygen_darwin_amd64
chmod +x telemetrygen_darwin_amd64
sudo mv telemetrygen_darwin_amd64 /usr/local/bin/telemetrygen
```

--------------------------------

### Initialize Rust Tracer

Source: https://monoscope.tech/docs/sdks/opentelemetry

Initialize the tracer to automatically read OTEL environment variables and register the subscriber.

```rust
use opentelemetry::global;
use opentelemetry_sdk::trace::SdkTracerProvider;
use opentelemetry_sdk::Resource;
use tracing_opentelemetry::OpenTelemetryLayer;
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::util::SubscriberInitExt;

fn init_tracer() {
    let exporter = opentelemetry_otlp::SpanExporter::builder()
        .with_tonic()
        .build()
        .expect("Failed to create OTLP exporter");

    let provider = SdkTracerProvider::builder()
        .with_batch_exporter(exporter)
        .with_resource(Resource::default())
        .build();

    global::set_tracer_provider(provider.clone());

    tracing_subscriber::registry()
        .with(OpenTelemetryLayer::new(provider.tracer("my-service")))
        .init();
}

#[tokio::main]
async fn main() {
    init_tracer();
    tracing::info!("Application started");
    global::shutdown_tracer_provider();
}
```

--------------------------------

### Example .env File for Data Redaction

Source: https://monoscope.tech/docs/sdks/php/laravel

Configure sensitive data redaction by setting environment variables in your .env file. This example shows redaction of headers, request body fields, and response body fields.

```sh
MONOSCOPE_REDACT_HEADERS="Content-Type, Authorization, HOST"
MONOSCOPE_REDACT_REQUEST_BODY="$.user.email, $.user.addresses"
MONOSCOPE_REDACT_RESPONSE_BODY="$.users[*].email, $.users[*].credit_card"
```

--------------------------------

### Configure Node.js Auto-Instrumentation

Source: https://monoscope.tech/docs/sdks/databases/mysql

Initialize the OpenTelemetry NodeSDK before importing database drivers to ensure proper trace capture.

```javascript
const { NodeSDK } = require('@opentelemetry/sdk-node');
const { getNodeAutoInstrumentations } = require('@opentelemetry/auto-instrumentations-node');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-proto');

const sdk = new NodeSDK({
  traceExporter: new OTLPTraceExporter({
    url: 'http://otelcol.monoscope.tech:4317/v1/traces',
  }),
  instrumentations: [getNodeAutoInstrumentations()],
  resourceAttributes: {
    'x-api-key': 'YOUR_API_KEY',
    'service.name': 'mysql-service',
  },
});

// Initialize the SDK before importing MySQL
sdk.start();

// Now it's safe to import and use MySQL
const mysql = require('mysql2/promise');
```

--------------------------------

### List Monitors using JavaScript

Source: https://monoscope.tech/docs/api-reference/endpoints/listmonitors

This JavaScript code snippet demonstrates how to retrieve a list of monitors using the Fetch API. Replace placeholders with your project ID and API key.

```javascript
const response = await fetch("https://api.monoscope.tech/api/v1/monitors?pid=YOUR_PROJECT_ID", {
  method: "GET",
  headers: {
    "Authorization": "Bearer YOUR_API_KEY",
    "Content-Type": "application/json"
  }
});
const data = await response.json();
console.log(data);
```
Tokens:
Raw