Intermediate 1-2 hours

Migrate from New Relic to TraceKit

Replace the New Relic agent with TraceKit's SDK-based instrumentation. No per-user pricing, no data ingest caps -- flat-rate APM with the same trace visibility.

Start Free

Replace New Relic Agent with TraceKit SDK

Remove the New Relic language agent (newrelic Go module, newrelic npm package, or newrelic Python package) and install the TraceKit SDK equivalent.

Category	New Relic	TraceKit	Notes
Package	github.com/newrelic/go-agent/v3/newrelic	github.com/tracekit/go-sdk	Go agent replacement
Package	newrelic (npm)	@tracekit/node-apm (npm)	Node.js agent replacement
Package	newrelic (pip)	tracekit-apm (pip)	Python agent replacement

Update License Key and Configuration

Replace New Relic license key and app name configuration with TraceKit API key and service name. Remove the newrelic.ini or newrelic.yml config file.

Category	New Relic	TraceKit	Notes
Authentication	NEW_RELIC_LICENSE_KEY	TRACEKIT_API_KEY	API key for trace ingestion
Service Identity	NEW_RELIC_APP_NAME	TRACEKIT_SERVICE_NAME	Application name for grouping
Config File	newrelic.yml / newrelic.ini	Environment variables or SDK init options	TraceKit prefers env vars over config files
Distributed Tracing	NEW_RELIC_DISTRIBUTED_TRACING_ENABLED=true	(enabled by default)	Distributed tracing is always on in TraceKit

Migrate Custom Transactions and Segments

Replace New Relic's transaction and segment API with TraceKit spans. New Relic's concept of transactions maps to root spans, and segments map to child spans.

Category	New Relic	TraceKit	Notes
Initialization	newrelic.NewApplication(newrelic.ConfigAppName(...))	tracekit.Init(apiKey, tracekit.WithService(...))	Application creation maps to SDK init
Transactions	app.StartTransaction(name)	tracekit.StartSpan(ctx, name)	Transactions become root spans
Segments	txn.StartSegment(name)	tracekit.StartSpan(ctx, name)	Segments become child spans (context carries parent)
Attributes	txn.AddAttribute(key, value)	span.SetAttribute(key, value)	Direct mapping for custom attributes

Update Error Tracking

Replace New Relic's error recording with TraceKit's span-level error recording. New Relic tracks errors at the transaction level; TraceKit attaches errors to the relevant span.

Category	New Relic	TraceKit	Notes
Error Recording	txn.NoticeError(err)	span.RecordError(err)	Error attached to current span, not transaction
Error Attributes	txn.NoticeError(newrelic.Error{Message: ..., Class: ...})	span.RecordError(err); span.SetAttribute("error.type", class)	Use attributes for error classification
Expected Errors	txn.NoticeExpectedError(err)	span.SetAttribute("error.expected", true)	Mark errors as expected via attribute

Verify Traces and Recreate Alerts

Start your instrumented application, generate traffic, and verify traces appear in TraceKit. Then recreate your critical New Relic alert conditions as TraceKit alerts.

Category	New Relic	TraceKit	Notes
Verification	New Relic One > APM > Transactions	TraceKit Dashboard > Traces	Verify trace data appears
Verification	New Relic One > Distributed Tracing	TraceKit Service Map	Check cross-service trace linking
Alerting	New Relic Alerts & AI > Policies	TraceKit Alerts	Recreate critical alert conditions

Code Examples

Before (New Relic)

import "github.com/newrelic/go-agent/v3/newrelic"

func main() {
    app, _ := newrelic.NewApplication(
        newrelic.ConfigAppName("my-service"),
        newrelic.ConfigLicense("YOUR_NEW_RELIC_LICENSE_KEY"),
        newrelic.ConfigDistributedTracerEnabled(true),
    )

    txn := app.StartTransaction("process-order")
    defer txn.End()
    segment := txn.StartSegment("fetch-inventory")
    // ... business logic
    segment.End()
}

After (TraceKit)

import "github.com/tracekit/go-sdk/tracekit"

func main() {
    tracekit.Init("tk_your_api_key",
        tracekit.WithService("my-service"),
        tracekit.WithEnvironment("production"),
    )
    defer tracekit.Shutdown(context.Background())

    ctx, span := tracekit.StartSpan(context.Background(), "process-order")
    defer span.End()
    _, child := tracekit.StartSpan(ctx, "fetch-inventory")
    // ... business logic
    child.End()
}

Before (New Relic)

const newrelic = require('newrelic');

// newrelic.js config file required:
// exports.config = {
//   app_name: ['my-service'],
//   license_key: 'YOUR_NEW_RELIC_LICENSE_KEY',
//   distributed_tracing: { enabled: true },
// };

const handle = newrelic.startWebTransaction('/api/orders', () => {
  newrelic.startSegment('fetch-inventory', true, () => {
    // ... business logic
  });
});

After (TraceKit)

const tracekit = require('@tracekit/node-apm');

tracekit.init({
  apiKey: 'tk_your_api_key',
  service: 'my-service',
  environment: 'production',
});

const span = tracekit.startSpan('/api/orders');
const child = tracekit.startSpan('fetch-inventory', { parent: span });
// ... business logic
child.end();
span.end();

Before (New Relic)

import newrelic.agent

newrelic.agent.initialize('newrelic.ini')
application = newrelic.agent.register_application()

@newrelic.agent.background_task()
def process_order(order_id):
    with newrelic.agent.FunctionTrace(name='fetch-inventory'):
        # ... business logic
        pass

After (TraceKit)

import tracekit

tracekit.init(
    api_key='tk_your_api_key',
    service='my-service',
    environment='production',
)

def process_order(order_id):
    with tracekit.start_span('process-order') as span:
        with tracekit.start_span('fetch-inventory') as child:
            # ... business logic
            pass

Related Resources

TraceKit vs New Relic

Full-stack observability with usage-based pricing. See how TraceKit compares for small teams.

Nuxt Observability

Nuxt splits your application across server middleware, Nitro engine routes, and Vue client plugins -- each with its own execution context. TraceKit traces all three layers so you can see where server processing ends and client hydration begins.

Go Distributed Tracing Guide

Learn distributed tracing patterns and best practices for Go

APM Implementation Checklist

Step-by-step APM implementation checklist covering SDK installation, instrumentation, alerting, and production rollout with OpenTelemetry best practices.

OTel Config Generator

Generate OpenTelemetry Collector configurations for your stack

Ready to migrate?

Start your free TraceKit account and follow this guide to migrate from New Relic in 1-2 hours.

Start Free Migration