azure-monitor-opentelemetry-ts
by microsoftazure-monitor-opentelemetry-ts helps instrument Node.js apps with Azure Monitor and OpenTelemetry for distributed traces, metrics, and logs. Use this azure-monitor-opentelemetry-ts skill to install the package, set APPLICATIONINSIGHTS_CONNECTION_STRING, and follow the correct startup order for auto-instrumentation.
This skill scores 78/100, which means it is a solid listing candidate for directory users who want a focused Azure Monitor/OpenTelemetry setup guide for TypeScript and Node.js. The repository shows enough real workflow content to help an agent trigger and execute the skill with less guesswork than a generic prompt, though it is narrower than a full end-to-end observability playbook.
- Explicit use case and trigger: instrument Node.js apps with Azure Monitor/OpenTelemetry for tracing, metrics, and logs.
- Operationally clear quick start with a strict ordering note to call useAzureMonitor() before importing other modules.
- Concrete install and environment guidance, including package names, connection string setup, and ESM loader usage.
- No install command or companion scripts/resources, so adoption still relies on reading the SKILL.md carefully.
- Scope appears centered on SDK setup and auto-instrumentation; users needing broader observability architecture or troubleshooting may need additional documentation.
Overview of azure-monitor-opentelemetry-ts skill
What azure-monitor-opentelemetry-ts does
The azure-monitor-opentelemetry-ts skill helps you instrument Node.js applications with Azure Monitor using OpenTelemetry, so you can collect distributed traces, metrics, and logs with less manual wiring. It is most useful when you want Application Insights-style observability without building a custom telemetry pipeline from scratch.
Who should use it
This azure-monitor-opentelemetry-ts skill is a good fit for developers working in TypeScript or JavaScript who need a practical azure-monitor-opentelemetry-ts for Observability setup in an existing app. It is especially relevant for teams standardizing on Azure, migrating from basic logging, or adding telemetry to Express and similar server-side workloads.
Why it is different
The main value is the azure-monitor-opentelemetry-ts install and startup order guidance: the skill is not just about adding a package, but about loading instrumentation before application imports so auto-instrumentation can actually work. That matters more than broad telemetry theory because a wrong import order can make the setup look successful while capturing little or nothing.
How to Use azure-monitor-opentelemetry-ts skill
Install the package and confirm the runtime fit
For azure-monitor-opentelemetry-ts install, start by adding the distro package: npm install @azure/monitor-opentelemetry. Use the lower-level exporter or ingestion packages only if you already know you need a custom OpenTelemetry configuration or custom log ingestion path. Check your Node.js version and module format early, because the ESM loader path requires Node.js 18.19+.
Give the skill a complete observability goal
A strong azure-monitor-opentelemetry-ts usage request should include the app type, runtime, and the telemetry you need. For example: “Instrument this Node.js 20 Express API with Azure Monitor, capture incoming requests, dependency calls, and application logs, and assume I will use APPLICATIONINSIGHTS_CONNECTION_STRING from environment variables.” That is better than “add monitoring” because it gives the skill enough context to choose auto-instrumentation, environment setup, and a realistic implementation path.
Follow the implementation order
For best results, make useAzureMonitor() the first thing executed before importing other modules. Then wire the connection string through azureMonitorExporterOptions, validate environment variables, and only after that load the rest of your app. If you are using ESM, use the documented Node import hook approach instead of trying to replicate CommonJS startup patterns.
Read the right files first
Start with SKILL.md in the repository, then inspect any linked README or package metadata if present in the skill bundle. For this repository, the highest-signal content is the installation block, environment variable section, quick start, and ESM support example. Those are the parts that most affect whether the azure-monitor-opentelemetry-ts guide will work in your codebase on the first pass.
azure-monitor-opentelemetry-ts skill FAQ
Is azure-monitor-opentelemetry-ts only for Azure-hosted apps?
No. The telemetry can be used in Node.js apps regardless of where they run, but the destination and operational model are Azure Monitor / Application Insights. If you do not plan to send traces, metrics, or logs into that ecosystem, this may not be the best fit.
Do I need OpenTelemetry experience first?
No, but basic familiarity helps. The skill is useful when you want Azure Monitor integration without designing every exporter and processor yourself. If you already maintain a heavily customized OpenTelemetry stack, this skill may overlap with work you have already standardized.
Can I use it for any JavaScript project?
It is best for server-side Node.js applications. It is not a general browser analytics solution, and it is not the right choice if your goal is only client-side event tracking or a non-Node runtime.
When should I not use this skill?
Skip azure-monitor-opentelemetry-ts if you need a telemetry design that is mostly vendor-neutral, if you cannot change startup order, or if your app structure makes auto-instrumentation hard to apply safely. In those cases, a manual prompt or a lower-level OpenTelemetry approach may be more appropriate.
How to Improve azure-monitor-opentelemetry-ts skill
Provide the details that change the setup
The biggest quality gains come from specifying runtime version, module system, framework, and deployment target. A request like “Node.js 18 CommonJS app using Express, deployed in Azure App Service, needs request tracing plus error logs” is far better than a generic monitoring request because it lets the skill avoid incompatible startup advice and focus on the right path.
Be explicit about telemetry scope
State whether you want only traces, or traces plus metrics and logs. Mention whether you need default auto-instrumentation, custom exporters, or custom log ingestion. The azure-monitor-opentelemetry-ts skill works best when the input clearly distinguishes “basic visibility” from “full observability pipeline.”
Watch for the common failure modes
The most common mistakes are importing application modules before useAzureMonitor(), missing APPLICATIONINSIGHTS_CONNECTION_STRING, and mixing ESM guidance with CommonJS execution. If the first output looks incomplete, iterate by adding your exact entry file, package type, and any existing telemetry library you are replacing.
Iterate with a concrete target file
Ask for changes against the real entrypoint, not just a conceptual setup. For example: “Update src/index.ts to initialize Azure Monitor before all imports, and explain any environment variables needed for staging and production.” That keeps the azure-monitor-opentelemetry-ts skill anchored to code you can apply immediately and reduces guesswork after the first pass.