@segment/analytics-react-native

The hassle-free way to add Segment analytics to your React-Native app.

⚠️ This readme covers analytics-react-native 2.0.0 and greater. The code and readme for analytics-react-native versions below 2.0.0 can be found on the analytics-react-native-v1 branch.

Table of Contents

• @segment/analytics-react-native
  • Table of Contents
  • Installation
    • Expo
    • Permissions
  • Migrating
  • Usage
    • Setting up the client
    • Client Options
    • iOS Deep Link Tracking Setup
    • Usage with hooks
    • useAnalytics()
    • Usage without hooks
  • Client methods
    • Track
    • Screen
    • Identify
    • Group
    • Alias
    • Reset
    • Flush
    • (Advanced) Cleanup
  • Automatic screen tracking
    • React Navigation
    • React Native Navigation
  • Plugins + Timeline architecture
    • Plugin Types
    • Destination Plugins
    • Adding Plugins
    • Writing your own Plugins
    • Supported Plugins
  • Contributing
  • Code of Conduct
  • License

Installation

Install @segment/analytics-react-native, @segment/sovran-react-native and react-native-async-storage/async-storage:

yarn add @segment/analytics-react-native @segment/sovran-react-native @react-native-async-storage/async-storage 
# or
npm install --save @segment/analytics-react-native @segment/sovran-react-native @react-native-async-storage/async-storage

For iOS, install native modules with:

npx pod-install

⚠️ For Android, you will have to add some extra permissions to your AndroidManifest.xml.

Expo

🚀 @segment/analytics-react-native 2.0 is compatible with Expo's Custom Dev Client and EAS builds without any additional configuration. Destination Plugins that require native modules may require custom Expo Config Plugins.

⚠️ @segment/analytics-react-native 2.0 is not compatible with Expo Go.

Permissions

Android

In your app's `AndroidManifest.xml` add the below line between the `` tags.

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

Migrating

See the Migration Guide for a detailed walkthrough of the changes you will need to make when upgrading to analytics-react-native 2.0

Usage

Setting up the client

The package exposes a method called createClient which we can use to create the Segment Analytics client. This central client manages all our tracking events.

import { createClient } from '@segment/analytics-react-native';

const segmentClient = createClient({
  writeKey: 'SEGMENT_API_KEY'
});

You must pass at least the writeKey. Additional configuration options are listed below:

Client Options

Name	Default	Description
writeKey (REQUIRED)	''	Your Segment API key.
debug	true*	When set to false, it will not generate any logs.
flushAt	20	How many events to accumulate before sending events to the backend.
flushInterval	30	In seconds, how often to send events to the backend.
maxBatchSize	1000	How many events to send to the API at once
trackAppLifecycleEvents	false	Enable automatic tracking for app lifecycle events: application installed, opened, updated, backgrounded)
trackDeepLinks	false	Enable automatic tracking for when the user opens the app via a deep link (Note: Requires additional setup on iOS, see instructions)
defaultSettings	undefined	Settings that will be used if the request to get the settings from Segment fails
autoAddSegmentDestination	true	Set to false to skip adding the SegmentDestination plugin

* The default value of debug will be false in production.

iOS Deep Link Tracking Setup

Note: This is only required for iOS if you are using the trackDeepLinks option. Android does not require any additional setup

To track deep links in iOS you must add the following to your AppDelegate.m file:

  @import segment_analytics_react_native;
  
  ...
  
- (BOOL)application:(UIApplication *)application
            openURL: (NSURL *)url
            options:(nonnull NSDictionary<UIApplicationOpenURLOptionsKey, id> *)options {
  
  [AnalyticsReactNative trackDeepLink:url withOptions:options];  
  return YES;
}

Usage with hooks

In order to use the useAnalytics hook within the application, we will additionally need to wrap the application in an AnalyticsProvider. This uses the Context API and will allow access to the analytics client anywhere in the application

import {
  createClient,
  AnalyticsProvider,
} from '@segment/analytics-react-native';

const segmentClient = createClient({
  writeKey: 'SEGMENT_API_KEY'
});

const App = () => (
  <AnalyticsProvider client={segmentClient}>
    <Content />
  </AnalyticsProvider>
);

useAnalytics()

The client methods will be exposed via the useAnalytics() hook:

import React from 'react';
import { Text, TouchableOpacity } from 'react-native';
import { useAnalytics } from '@segment/analytics-react-native';

const Button = () => {
  const { track } = useAnalytics();
  return (
    <TouchableOpacity
      style={styles.button}
      onPress={() => {
        track('Awesome event');
      }}
    >
      <Text style={styles.text}>Press me!</Text>
    </TouchableOpacity>
  );
};

Usage without hooks

The tracking events can also be used without hooks by calling the methods directly on the client:

import {
  createClient,
  AnalyticsProvider,
} from '@segment/analytics-react-native';

// create the client once when he app loads
const segmentClient = createClient({
  writeKey: 'SEGMENT_API_KEY'
});

// track an event using the client instance
segmentClient.track('Awesome event');

Client methods

Track

The track method is how you record any actions your users perform, along with any properties that describe the action.

Method signature:

track: (event: string, properties?: JsonMap) => void;

Example usage:

const { track } = useAnalytics();

track('View Product', {
  productId: 123,
  productName: 'Striped trousers',
});

Screen

The screen call lets you record whenever a user sees a screen in your mobile app, along with any properties about the screen.

Method signature:

screen: (name: string, properties?: JsonMap) => void;

Example usage:

const { screen } = useAnalytics();

screen('ScreenName', {
  productSlug: 'example-product-123',
});

For setting up automatic screen tracking, see the instructions below.

Identify

The identify call lets you tie a user to their actions and record traits about them. This includes a unique user ID and any optional traits you know about them like their email, name, etc. The traits option can include any information you might want to tie to the user, but when using any of the reserved user traits, you should make sure to only use them for their intended meaning.

Method signature:

identify: (userId: string, userTraits?: JsonMap) => void;

Example usage:

const { identify } = useAnalytics();

identify('user-123', {
  username: 'MisterWhiskers',
  email: 'hello@test.com',
  plan: 'premium',
});

Group

The group API call is how you associate an individual user with a group—be it a company, organization, account, project, team or whatever other crazy name you came up with for the same concept! This includes a unique group ID and any optional group traits you know about them like the company name industry, number of employees, etc. The traits option can include any information you might want to tie to the group, but when using any of the reserved group traits, you should make sure to only use them for their intended meaning.

Method signature:

group: (groupId: string, groupTraits?: JsonMap) => void;

Example usage:

const { group } = useAnalytics();

group('some-company', {
  name: 'Segment',
});

Alias

The alias method is used to merge two user identities, effectively connecting two sets of user data as one. This is an advanced method, but it is required to manage user identities successfully in some of our destinations.

Method signature:

alias: (newUserId: string) => void;

Example usage:

const { alias } = useAnalytics();

alias('user-123');

Reset

The reset method clears the internal state of the library for the current user and group. This is useful for apps where users can log in and out with different identities over time.

Note: Each time you call reset, a new AnonymousId is generated automatically.

Method signature:

reset: () => void;

Example usage:

const { reset } = useAnalytics();

reset();

Flush

By default, the analytics will be sent to the API after 30 seconds or when 20 items have accumulated, whatever happens sooner, and whenever the app resumes if the user has closed the app with some events unsent. These values can be modified by the flushAt and flushInterval config options. You can also trigger a flush event manually.

Method signature:

flush: () => Promise<void>;

Example usage:

const { flush } = useAnalytics();

flush();

(Advanced) Cleanup

You probably don't need this!

In case you need to reinitialize the client, that is, you've called createClient more than once for the same client in your application lifecycle, use this method on the old client to clear any subscriptions and timers first.

let client = createClient({
  writeKey: 'KEY'
});

client.cleanup();

client = createClient({
  writeKey: 'KEY'
});

If you don't do this, the old client instance would still exist and retain the timers, making all your events fire twice.

Ideally, you shouldn't need this though, and the Segment client should be initialized only once in the application lifecycle.

Automatic screen tracking

Sending a screen() event with each navigation action will get tiresome quick, so you'll probably want to track navigation globally. The implementation will be different depending on which library you use for navigation. The two main navigation libraries for React Native are React Navigation and React Native Navigation.

React Navigation

Our example app is set up with screen tracking using React Navigation, so you can use it as a guide.

Essentially what we'll do is find the root level navigation container and call screen() whenever user has navigated to a new screen.

Find the file where you've used the NavigationContainer - the main top level container for React Navigation. In this component, create a new state variable to store the current route name:

const [routeName, setRouteName] = useState('Unknown');

Now, outside of the component, create a utility function for determining the name of the selected route:

const getActiveRouteName = (
  state: NavigationState | PartialState<NavigationState> | undefined
): string => {
  if (!state || typeof state.index !== 'number') {
    return 'Unknown';
  }

  const route = state.routes[state.index];

  if (route.state) {
    return getActiveRouteName(route.state);
  }

  return route.name;
};

Finally, pass a function in the onStateChange prop of your NavigationContainer that checks for the active route name and calls client.screen() if the route has changes. You can pass in any additional screen parameters as the second argument for screen call as needed.

<NavigationContainer
  onStateChange={(state) => {
    const newRouteName = getActiveRouteName(state);

    if (routeName !== newRouteName) {
      segmentClient.screen(newRouteName);
      setRouteName(newRouteName);
    }
  }}
>

React Native Navigation

In order to setup automatic screen tracking while using React Native Navigation, you will have to use an event listener. That can be done at the point where you are setting up the root of your application (ie. Navigation.setRoot). There your will need access to your SegmentClient.

// Register the event listener for *registerComponentDidAppearListener*
Navigation.events().registerComponentDidAppearListener(({ componentName }) => {
  segmentClient.screen(componentName);
});

Plugins + Timeline architecture

You have complete control over how the events are processed before being uploaded to the Segment API.

In order to customise what happens after an event is created, you can create and place various Plugins along the processing pipeline that an event goes through. This pipeline is referred to as a Timeline.

Plugin Types

Plugin Type	Description
before	Executed before event processing begins.
enrichment	Executed as the first level of event processing.
destination	Executed as events begin to pass off to destinations.
after	Executed after all event processing is completed. This can be used to perform cleanup operations, etc.
utility	Executed only when called manually, such as Logging.

Plugins can have their own native code (such as the iOS-only IdfaPlugin) or wrap an underlying library (such as FirebasePlugin which uses react-native-firebase under the hood)

Destination Plugins

Segment is included as a DestinationPlugin out of the box. You can add as many other DestinationPlugins as you like, and upload events and data to them in addition to Segment.

Or if you prefer, you can pass autoAddSegmentDestination = false in the options when setting up your client. This prevents the SegmentDestination plugin from being added automatically for you.

Adding Plugins

You can add a plugin at any time through the segmentClient.add() method.

import { createClient } from '@segment/analytics-react-native';

import { AmplitudeSessionPlugin } from '@segment/analytics-react-native-plugin-amplitude-session';
import { FirebasePlugin } from '@segment/analytics-react-native-plugin-firebase';
import { IdfaPlugin } from '@segment/analytics-react-native-plugin-idfa';

const segmentClient = createClient({
  writeKey: 'SEGMENT_KEY'
});

segmentClient.add({ plugin: new AmplitudeSessionPlugin() });
segmentClient.add({ plugin: new FirebasePlugin() });
segmentClient.add({ plugin: new IdfaPlugin() });

Writing your own Plugins

Plugins are implemented as ES6 Classes. To get started, familiarise yourself with the available classes in /packages/core/src/plugin.ts.

The available plugin classes are:-

• Plugin
• EventPlugin
• DestinationPlugin
• UtilityPlugin
• PlatformPlugin

Any plugins must be an extension of one of these classes.

You can them customise the functionality by overriding different methods on the base class. For example, here is a simple Logger plugin:

// logger.js

import {
  Plugin,
  PluginType,
  SegmentEvent,
} from '@segment/analytics-react-native';

export class Logger extends Plugin {

  // Note that `type` is set as a class property
  // If you do not set a type your plugin will be a `utility` plugin (see Plugin Types above)
  type = PluginType.before;

  execute(event: SegmentEvent) {
    console.log(event);
    return event;
  }
}

// app.js

import { Logger } from './logger';

segmentClient.add({ plugin: new Logger() });

As it overrides the execute() method, this Logger will call console.log for every event going through the Timeline.

Supported Plugins

Refer to the following table for Plugins you can use to meet your tracking needs:

Plugin	Package
Adjust	@segment/analytics-react-native-plugin-adjust
Amplitude Sessions	@segment/analytics-react-native-plugin-amplitude-session
AppsFlyer	@segment/analytics-react-native-plugin-appsflyer
Braze	@segment/analytics-react-native-plugin-braze
Facebook App Events	@segment/analytics-react-native-plugin-facebook-app-events
Firebase	@segment/analytics-react-native-plugin-firebase
IDFA	@segment/analytics-react-native-plugin-idfa
Mixpanel	@segment/analytics-react-native-plugin-mixpanel
Taplytics	@taplytics/segment-react-native-plugin-taplytics

Contributing

See the contributing guide to learn how to contribute to the repository and the development workflow.

Code of Conduct

Before contributing, please also see our code of conduct.

License

MIT