The hassle-free way to add Segment analytics to your React-Native app.
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.
- @segment/analytics-react-native
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-storageFor iOS, install native modules with:
npx pod-installAndroidManifest.xml.
🚀 @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's managed workflow.
Android
In your app's `AndroidManifest.xml` add the below line between the `` tags.<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />See the Migration Guide for a detailed walkthrough of the changes you will need to make when upgrading to analytics-react-native 2.0
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:
| 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.
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;
}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>
);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>
);
};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');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',
});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.
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: '[email protected]',
plan: 'premium',
});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',
});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');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();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();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.
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.
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);
}
}}
>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);
});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 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)
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.
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() });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:-
PluginEventPluginDestinationPluginUtilityPluginPlatformPlugin
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.
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 |
See the contributing guide to learn how to contribute to the repository and the development workflow.
Before contributing, please also see our code of conduct.
MIT