---
title: "Configure Sampling"
description: "Learn how to configure sampling in your app using the Sentry JavaScript SDK."
url: https://docs.sentry.io/platforms/javascript/guides/cordova/tracing/configure-sampling/
---

# Configure Sampling for Cordova

Tracing follows page loads and requests so you can see where they fail or slow down. Capturing every trace can be a lot of data. Sampling controls how many spans your application sends to Sentry.

The JavaScript SDK provides two main options for controlling the sampling rate:

1. [Uniform Sample Rate](https://docs.sentry.io/platforms/javascript/guides/cordova/tracing/configure-sampling.md#uniform-sample-rate-tracessamplerate) (recommended)
2. [Sampling Function](https://docs.sentry.io/platforms/javascript/guides/cordova/tracing/configure-sampling.md#sampling-function-tracessampler)

## [Uniform Sample Rate (`tracesSampleRate`)](https://docs.sentry.io/platforms/javascript/guides/cordova/tracing/configure-sampling.md#uniform-sample-rate-tracessamplerate)

`tracesSampleRate` is floating point value 0.0 and 1.0, which controls the probability that a transaction will be sampled.

```javascript
Sentry.init({
  dsn: "https://<key>@o<orgId>.ingest.sentry.io/<projectId>",
  integrations: [Sentry.browserTracingIntegration()],
  // Capture 25% of all transactions
  tracesSampleRate: 0.25,
});
```

With `tracesSampleRate` set to `0.25`, each transaction in your application is randomly sampled with a probability of 25%, so you can expect that one in every four transactions will be sent to Sentry.

## [Sampling Function (`tracesSampler`)](https://docs.sentry.io/platforms/javascript/guides/cordova/tracing/configure-sampling.md#sampling-function-tracessampler)

For more granular control, you provide a `tracesSampler` function. This approach allows you to:

* Apply different sampling rates to different types of transactions
* Filter out specific transactions entirely
* Make sampling decisions based on transaction data
* Control the inheritance of sampling decisions in distributed traces

```javascript
Sentry.init({
  dsn: "https://<key>@o<orgId>.ingest.sentry.io/<projectId>",
  integrations: [Sentry.browserTracingIntegration()],
  tracesSampler: (samplingContext) => {
    // Access transaction details from the sampling context
    const { transactionContext, parentSampled } = samplingContext;

    // Skip health checks entirely
    if (transactionContext.name.includes("healthcheck")) {
      return 0;
    }

    // Capture all auth-related transactions
    if (transactionContext.name.includes("auth")) {
      return 1;
    }

    // Sample only 1% of comment-related transactions
    if (transactionContext.name.includes("comment")) {
      return 0.01;
    }

    // For everything else, inherit the parent sampling decision or use 0.5
    return parentSampled !== undefined ? parentSampled : 0.5;
  },
});
```

### [The Sampling Context Object](https://docs.sentry.io/platforms/javascript/guides/cordova/tracing/configure-sampling.md#the-sampling-context-object)

When the `tracesSampler` function is called, it receives a `samplingContext` object with valuable information to help make sampling decisions:

```typescript
interface SamplingContext {
  // Context of the transaction, including its initial `name` and `op`
  transactionContext: TransactionContext;

  // Whether the parent transaction was sampled (undefined if there's no parent)
  parentSampled: boolean | undefined;

  // The current `window.location`
  location: Location | undefined;
}
```

### [Traces Sampler Examples](https://docs.sentry.io/platforms/javascript/guides/cordova/tracing/configure-sampling.md#traces-sampler-examples)

1. Prioritizing Critical User Flows

```javascript
tracesSampler: (samplingContext) => {
  const { transactionContext, parentSampled } = samplingContext;

  // Sample all checkout transactions
  if (transactionContext.name.includes("/checkout")) {
    return 1.0;
  }

  // Sample 50% of login transactions
  if (transactionContext.name.includes("/login")) {
    return 0.5;
  }

  // Sample 10% of everything else, unless there's a parent sampling decision
  return parentSampled !== undefined ? parentSampled : 0.1;
};
```

2. Handling Different Environments

```javascript
tracesSampler: (samplingContext) => {
  // Sample all transactions in development
  if (process.env.NODE_ENV === "development") {
    return 1.0;
  }

  // Sample 5% in production
  if (process.env.NODE_ENV === "production") {
    return 0.05;
  }

  // Sample 20% in staging
  return 0.2;
};
```

## [Sampling Decision Precedence](https://docs.sentry.io/platforms/javascript/guides/cordova/tracing/configure-sampling.md#sampling-decision-precedence)

When multiple sampling mechanisms could apply, Sentry follows this order of precedence:

* If `tracesSampler` is defined, its decision is used. Although the `tracesSampler` can override the parent sampling decision, most users will want to ensure their `tracesSampler` respects the parent sampling decision.
* If no `tracesSampler` is defined, but there is a parent sampling decision from an incoming distributed trace, we use the parent sampling decision
* If neither of the above, `tracesSampleRate` is used
* If `tracesSampleRate` is set to 0, no spans will be sampled, and no downstream spans will be sampled either since they inherit the parent sampling decision
* If none of the above are set, no transactions are sampled and tracing will be disabled

## [Conclusion](https://docs.sentry.io/platforms/javascript/guides/cordova/tracing/configure-sampling.md#conclusion)

Sampling keeps enough traces to debug failures and slowdowns without sending every span. The `tracesSampler` function controls which traces to record.
