Advanced 2-4 hours

Migrate from Dynatrace to TraceKit

Replace Dynatrace OneAgent with TraceKit's SDK-based approach. No per-host licensing, no DDU calculations -- flat-rate pricing with full trace visibility.

Start Free

Remove OneAgent and Plan SDK Integration

Dynatrace uses an agent-based model (OneAgent) installed on each host. TraceKit uses lightweight SDK libraries embedded in your application code. Plan which services to migrate first, starting with the least critical.

Category	Dynatrace	TraceKit	Notes
Deployment	OneAgent (host-level installer)	TraceKit SDK (application dependency)	No host-level agent required
Deployment	ActiveGate (cluster component)	(not needed)	No gateway component; SDK sends direct to cloud
Deployment	DT_TENANT (SaaS tenant URL)	TRACEKIT_ENDPOINT	Single endpoint for all ingestion

Install TraceKit SDK Packages

Add TraceKit SDK to each service. Unlike OneAgent's automatic discovery, TraceKit uses explicit instrumentation for precise control over what gets traced.

Category	Dynatrace	TraceKit	Notes
Package	OneAgent auto-instrumentation	github.com/tracekit/go-sdk (Go)	Explicit SDK installation per service
Package	OneAgent auto-instrumentation	@tracekit/node-apm (Node.js)	npm package with auto-instrumentation hooks
Package	OneAgent auto-instrumentation	tracekit-apm (Python)	pip package with WSGI/ASGI middleware

Map Dynatrace Configuration to TraceKit

Translate Dynatrace environment configuration and OneAgent settings to TraceKit SDK configuration. Dynatrace uses tenant-level config and host groups; TraceKit uses per-service configuration.

Category	Dynatrace	TraceKit	Notes
Authentication	DT_API_TOKEN (API v2 token)	TRACEKIT_API_KEY	Single API key for all operations
Service Identity	DT_CUSTOM_PROP (host-level properties)	TRACEKIT_TAGS	Service-level tags instead of host properties
Service Identity	DT_TAGS (host tags)	TRACEKIT_TAGS	Both map to key=value tag pairs
Service Identity	DT_CLUSTER_ID	TRACEKIT_SERVICE_NAME	Cluster grouping maps to service name
Network	DT_NETWORK_ZONE	TRACEKIT_ENDPOINT	Use region-specific endpoint URL

Replace PurePath Instrumentation with Spans

Dynatrace PurePaths are automatically captured end-to-end transactions. In TraceKit, you create explicit spans that link via context propagation. For custom services and request attributes, replace Dynatrace SDK calls.

Category	Dynatrace	TraceKit	Notes
Tracing	PurePath (automatic)	tracekit.StartSpan(ctx, name)	Explicit span creation with context propagation
Tracing	OneAgent SDK createTracer()	tracekit.StartSpan(ctx, name)	Custom tracer creation maps to span creation
Attributes	addCustomRequestAttribute(key, val)	span.SetAttribute(key, val)	Request attributes become span attributes
Errors	oneagentsdk.addCustomErrorInfo()	span.RecordError(err)	Error info attached to spans

Migrate Custom Services and Request Attributes

In Dynatrace, custom services are defined through rules in the UI or via OneAgent SDK. In TraceKit, services are identified by the TRACEKIT_SERVICE_NAME and custom attributes on spans.

Category	Dynatrace	TraceKit	Notes
Services	Custom Service detection rules (UI)	TRACEKIT_SERVICE_NAME per deployment	Each microservice sets its own service name
Services	Request Attribute rules (UI)	span.SetAttribute() in code	Attributes set in code, not UI rules
Services	Calculated service metrics	TraceKit Dashboard metrics	Automatic latency/error rate metrics per service

Verify Traces and Update Alerting

Deploy the migrated services, generate traffic, and verify traces in TraceKit. Recreate Dynatrace problem detection rules as TraceKit alerts. Note that Davis AI anomaly detection does not have a direct equivalent -- you will set explicit threshold-based alerts.

Category	Dynatrace	TraceKit	Notes
Verification	Dynatrace > PurePaths	TraceKit Dashboard > Traces	Verify end-to-end trace capture
Verification	Dynatrace > Smartscape topology	TraceKit Service Map	Verify service dependency mapping
Alerting	Davis AI problem detection	TraceKit Alerts (threshold-based)	Set explicit P95/error rate thresholds

Code Examples

Before (Dynatrace)

// Dynatrace: OneAgent auto-instruments Go applications
// No code changes needed for basic tracing
// For custom spans, use the OneAgent SDK:
import "github.com/Dynatrace/OneAgent-SDK-for-Go/onesdk"

func processOrder(ctx context.Context) {
    tracer := onesdk.CreateTracer()
    tracer.Start()
    defer tracer.End()

    tracer.AddCustomRequestAttribute("order.type", "premium")
    // ... business logic
}

After (TraceKit)

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

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

func processOrder(ctx context.Context) {
    ctx, span := tracekit.StartSpan(ctx, "process-order")
    defer span.End()

    span.SetAttribute("order.type", "premium")
    // ... business logic
}

Before (Dynatrace)

// Dynatrace: OneAgent auto-instruments Node.js
// Require the agent at the top of your entry file:
require('@dynatrace/oneagent-sdk');

const sdk = require('@dynatrace/oneagent-sdk').createInstance();
const tracer = sdk.traceIncomingRemoteCall({
  serviceMethod: 'processOrder',
  serviceName: 'OrderService',
  serviceEndpoint: '/api/orders',
});

tracer.start(() => {
  tracer.addCustomRequestAttribute('order.type', 'premium');
  // ... business logic
  tracer.end();
});

After (TraceKit)

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

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

const span = tracekit.startSpan('processOrder');
span.setAttribute('order.type', 'premium');
// ... business logic
span.end();

Before (Dynatrace)

# Dynatrace: OneAgent auto-instruments Python
# Install OneAgent on the host, then use SDK for custom spans:
import oneagent

sdk = oneagent.get_sdk()

with sdk.trace_incoming_remote_call(
    'process_order', 'OrderService', '/api/orders'
) as tracer:
    sdk.add_custom_request_attribute('order.type', 'premium')
    # ... business logic

After (TraceKit)

import tracekit

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

with tracekit.start_span('process-order') as span:
    span.set_attribute('order.type', 'premium')
    # ... business logic

Related Resources

TraceKit vs Dynatrace

AI-powered enterprise observability at enterprise prices. See how TraceKit delivers core APM without the complexity.

Rails Observability

Rails convention over configuration extends to observability problems -- N+1 queries hide behind eager-loading defaults, Sidekiq jobs run in separate processes, and view rendering can silently dominate response time. TraceKit makes it all visible.

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 Dynatrace in 2-4 hours.

Start Free Migration