Android

Implementation

In order to start working with Cooladata Android SDK watch the video tutorial or follow the steps below:

 

Step 1 – Add Cooladata SDK to your project

The CoolaData Android SDK support Android version 2.3 and up. The library depends on OkHttp library. All sending, storing and reading of data is done on a background thread.
Choose one of the following options to add the SDK to your project:

  • As a Gradle dependency:
    dependencies {compile 'com.cooladata.android:android-sdk:2.2.3'}
  • As a Maven dependency:
    <dependency>
    <groupId>com.cooladata.android</groupId>
    <artifactId>android-sdk</artifactId>
    <version>2.2.3</version>
    </dependency>
  • Download Jar with transitive dependencies (will include OkHttp artifact) or without transitive dependencies and copy it into the “libs” folder in your Android project. If you will be using the jar without embedded dependencies please validate that in case you have the OkHttp library on your classpath as well.
  • Embed the source code in your project using source Jar.

 

Step 2 – Manifest.xml configuration

To ensure that you request the permissions required for the library to work, add the following permissions within the AndroidManifest.xml element:

<!-- Mandatory permission -->
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
 
<!-- Optional, but recommended to preserve battery usage -->
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>

 

Step 3 – Initialization

Initialize the tracker by calling the CoolaDataTracker.setup method:

public class MyApplication extends Application {
...
    @Override 
    public void onCreate() {
        super.onCreate();
        
        // init the cooladata tracker with app key and user id
        // NOTE - Do not forget to replace the app key and the user id to your own values
        CoolaDataTracker.setup(this,
            new CoolaDataTrackerOptions("aknek0zuo8i4ztcmgopn5wotsceg80m9"));
    }
...
}

We recommend calling the setup method once from Application.onCreate.

 

Step 4 – Track Events

Call the trackEvent method from your activity:

void CoolaDataTracker.trackEvent(String eventName, Map<string, object="", eventProperties);

The SDK collects the events you tracked and sends them every few seconds, or once the buffer is full (to conserve battery and network usage). If you want to manually send events immediately to CoolaData, call CoolaDataTracker.flush:

@Override
protected void onDestroy() {
super.onDestroy();
CoolaDataTracker.flush();
}

We recommend to always call flush from the Activity.onDestroy method, to avoid losing the last few events.

 

Full API Reference

Setup

The setup method used to initialize a new CoolaDataTracker singleton object.

void CoolaDataTracker.setup(Context applicationContext, CoolaDataTrackerOptions setupOptions);

Setup Parameters:

NameTypeMandatoryDescription
contextContextYesThe application context
optionsCoolaData Tracker OptionsYesSee below

Setup Options:

NameTypeMandatoryDescription
appKeyStringYesThe AppKey provided by CoolaData.
userIdStringNoExplicit user ID for this device. Providing userId will override the system userId. During the initialization the SDK will try to search for user_id in the following order:
1. “user_id” property
2. advertising ID if available
3. Device id if has permission
4. If none of above succeed a random UUID will be assigned for the current user.

trackEvent

trackEvent method syntax:

void CoolaDataTracker.trackEvent(String eventName, Map<string, object=""> eventProperties);

Tracker Parameters:

NameTypeMandatoryDescription
eventNameStringYesThe name of the event to report
userIDStringNoExplicit user ID for this event - should only be provided for manual user management
sessionIdStringNoExplicit session id for this event - should only be provided for manual session management
eventPropertiesMapNoThe custom properties to be sent with the event

Examples:

  • Track a “search” event:
    CoolaDataTracker.trackEvent("Search");
  • Track an “add to cart” event with “product type” and “amount” properties:
    Map<String, Object> properties = new HashMap<String, Object>();
    properties.put("Type", "T-Shirt");
    properties.put("Amount", 2);
    
    // track event with properties
    CoolaDataTracker.trackEvent("Add Item", properties);
  • Track a “checkout” event with “status”, “amount” and “username”:
    Map<String, Object> properties = new HashMap<String, Object>();
    properties.put("Status", "success");
    properties.put("Amount", 50.99);
    
    // track event with properties
    CoolaDataTracker.trackEvent("Add Item", getCurrentLoggedInUser(), properties);

Session Management

CoolaData groups consecutive events into session automatically (according to the project settings). To manually override session management, session attribute can be provided. For example:

CoolaDataTracker.trackEvent("Add Item", getCurrentLoggedInUser(), “A3E1-338F-BB12-CD81”, properties);

Campaign Tracking

CoolaData provides the ability to track marketing campaigns for Android, by automatically setting properties associated with how users find an app in the Google Play Store. To enable this feature, add the Install Referrer Receiver, or add the following tag to the tag in the AndroidManifest.xml file:

receiver
  android:name="com.cooladata.android.ReferrerReceiver"
  android:exported="true">
  <intent-filter>
    <action
	android:name="com.android.vending.INSTALL_REFERRER" />
  </intent-filter>
</receiver>

Once the AndroidManifest.xml file is updated, you will automatically send referrer and utm properties (campaign, content, medium, source, and term) information together with each event that you send to CoolaData.

The best way to test this type of referral tracking is to use adb to send the installation intent. Once connected via the adb shell, the following command should be used:

am broadcast -a com.android.vending.INSTALL_REFERRER -n your.pacakage.name.here/.ReferralReceiver --es "referrer" 
"utm_source%3dtest_source%26utm_medium%3dtest_medium%26utm_term%3dtest_term%26utm_content%3dtest_content%26utm_campaign%3dtest_name"

For additional information on how to test a Google Play campaign measurement implementation click here.

 

Change Notes

datechange
20/12/2015Ability to disable identity tracking. (if set to true, tracker won't try to resolve device id or advertising id for username). Please note that this feature is not included into official 2.2.3 release, only as custom build. Will be released as a part of 2.2.4 release.
11/11/2015Start using OkHttp as HTTP layer, yet remained ability to use old HTTP layer for compatibility issues (.setUseOldHttpClient(true) option)
7/11/2015Move using standard JSON library (not sure whether it worth adding to release notes, anyway added this here)
19/10/2015Time calibration meachnism improvement (avoid excessive calls to time calibration API)
14/10/2015Add custome event handler support (Coca Cola request) - ability to add custom way to ahndle tracking cooladata tracker events. Events are not sent to cooladata when custom tracker is in use.
12/10/2015Add time callibration to send events using server time
20/9/2015Exception logging
13/4/2015Added thresholds support to controll memory used by tracker (queues while device is offline, or between flushes), however not in use yet
19/1/2015Added support for advertizing ID retreival. Now if user ID was not provided and app has access to advertizong ID than username is set to advertizing ID.
16/1/2015Generated random UID became persistent between application sessions. Added device connectivity state check.
31/12/2014User ID is not mandatory any more for tracker initialization. Device ID will be used if no user id provided. In case no permission to get Device ID then random UUID will be assigned.

February 2018 Release Notes

Connect

We are constantly adding more ways to connect your data with Cooladata, to provide you with a single point of management for your data. We aim to make new connections available to any user, with just a few clicks, so you can configure them yourself and not need R&D to get insights quickly.

Data Sources Page (Admins only)

The new Data Sources Page provides you with an overview of the multitude of ways you can connect with Cooladata, both for sending data and querying it. To access the page, from the project menu, select Data Sources. Here, browse through the different categories: Event sources, Integrations, Linked data sources and BI Tools, and click an item to learn more about it.

​​

​Integrations (Admins only)

Salesforce

Salesforce develops CRM solutions that help customers increase sales, improve customer service, collaborate with their team, and develop customized applications on the Salesforce platform.

Integrating Salesforce into your Cooladata account will and allow you to enrich the behavioral data tracked by Cooladata with your CRM data.

Setting up the Salesforce integration will fetch the following Salesforce objects: Leads, Opportunities, Accounts, Contacts, Price books, Products, Campaigns, Events.

All the above objects’ fields, standard and custom, are fetched. See each object’s standard fields list here.
Data is updated daily. To configure a specific update hour please contact us at support@cooladata.com.

Intercom

Intercom is a powerful set of tools for better managing your company’s customer support system. It includes a help center with a feedback system, which you can use to focus future articles on the growing needs of your customers, and it also provides a robust conversation system that allows you to assign support teams to customers based on specific criteria (about the customer or discussion topic), rather than just based on availability. Intercom is designed to create a more effective customer support network by specifically tracking and targeting your customers’ needs.

Cooladata’s integration with Intercom empowers marketers and customer management teams to understand the entire user journey, and the impact of Intercom on their users’ lifetime and value.

The integration runs daily, updating the previous day’s end of day data in each table: intercom_conversations, intercom_users.

To integrate Intercom to your Cooladata project please contact your customer success manager or email us at support@cooladata.com.

Google Search Console

Google Search console (GSC) is a collection of Google SEO tools and reporting. It offers data and configuration control for your website as well as a variety of visitor metrics.

As an online marketer, the GSC “search analytics” section is probably the most useful report for you. GSC “search analytics” delivers insights into how your website is performing in regards to the overall organic search traffic from Google. You can see the most popular queries, pages, countries and devices. Additionally, for better understanding of your website’s performance in Google’s search results, you can use different filters to segment traffic even further. See what keyword searches on Google led to the site being listed in the SERPs, and the click through rates of such listings.

Google Sheets

The Google Sheets integration enables you to use your Google Spreadsheets as tables in your Cooladata project, and query them directly from your Cooladata project.

Connected spreadsheets are always updated and reflect the exact data your sheet contains.

The new table will be added to your project Schema, under Integration Tables, in the Table Name you selected. Query it by using the following syntax:

FROM < table name >

Firebase

Firebase is Google’s mobile platform that helps you quickly develop high-quality apps and grow your business.

You can now integrate Firebase with Cooladata so that all the events generated by Analytics for Firebase will be sent as any other event to your Cooladata project.

To do so, you will need to link your Firebase app to BigQuery. Linking your Firebase app to BigQuery allows you to access your raw, unsampled event data along with all of your parameters and user properties.

Once you’ve linked your Firebase app to a BigQuery project, we will connect it to your Cooladata project. This will stream all your event data directly into your Cooladata project, where you can query, export or join your data with data from other platforms and data sources in your project, to perform custom analysis.

To set up a new Firebase integration, contact your Customer Success Manager or email us at support@cooladata.com.

Process

Aggregation Tables – Run Multiple Tasks Per Table (Admins only)

You can now create multiple tasks per table. Each item in the Aggregation Tables page is now a task, which runs on a table. This enabled you to run several ETL processes for the same table, for example: extracting data from you Linked Database, adding column to include specific data, and running aggregations on that data. When creating a task you can select to run on an existing tables, or create a new table. Task name can be anything you want.

 

​URL Parameter Virtual Properties (Admins only)

This new virtual property lets you create a separate property from any parameter sent in your webpage URL. Use this to extract any lead information passed from marketing campaigns, forms, etc. To create a new virtual property, from the project menu select Properties, click the + icon, and choose URL Parameter. All virtual properties are calculated on the fly, and can be modified at any time.


Expressions in Virtual Properties (Admins only)

Previously you could use two types of calculations in virtual properties: Virtual Dimension and Virtual Measure. To simplify the process, we have combined both capabilities to one, easy to use type. In this new virtual property type, you can enter any CQL expression you want to calculate, be it a function, CASE, or calculation based on other properties. Existing Virtual Dimensions have been automatically converted to the equivalent CASE expression. Unlike Virtual Dimension, where you could only use strings as the results of the CASE expression, with Expression you can select any value, includes calculations on the data.


Insights

R and Python Reports

In the modern world of analytics, SQL queries can only go so far. Powerful insights rely on advanced machine learning and AI algorithms. Now, you can incorporate any such scripts in Cooladata.

As a first step, we enable you to run R and Python scripts in your reports. Run any script and plot any visualization to be shown in a report, embedded reports, dashboards or publications.

To create a new R or Python Report, from the New Report gallery go to Scripts and choose the report type. Enter the CQL query in the top section to draw the data, and run the script below. To use a library, see list of pre-installed libraries in the script, or add new ones in “Additional Libraries”.

Note that this feature is still in beta – your feedback will be much appreciated!


Alerts Builder (Admins only)

Getting notified on business events is critical to managing your business. To help you with this, Cooladata enables email alerts to be sent on a scheduled basis, whenever a condition applies in your data. Now you can set advanced behavioral triggers yourself, without writing the CQL query. Get alerted on changes in users activity, events and property values, compared to preceding period or parallel historical periods. To create a new alert, from the project menu select Alerts, click the + icon and select Builder. Set your trigger condition and schedule, and add any pertinent info and reports to the email body.


PIVOT CQL Function

Data is constantly changing, and requires us to change with it. When dissecting data across various dimensions, we often need to update our analysis as the dimensions changes. To help you automate this process, we have added support to the useful PIVOT function in our CQL (Cooladata SQL) language. Like in the pivot visualization, the PIVOT function lets use convert row values of a specific dimension to multiple columns, allowing you to treat each as a measure and compare them side by side in a single chart. See the PIVOT documentation for the exact syntax and options in the function.

In the following example we converted country values to columns, showing them together in a bar chart.


Share

Mobile Support

You can now view reports and dashboards on your mobile device. Specifically designed to let you access reports sent to your email, the mobile support also fits complete dashboards in the palm of your hand, to let you access them anywhere, anytime. Open Cooladata on a mobile Chrome browser to access it.


White Label Publications

Share reports with your clients via email directly from Cooladata. You can now request to set all your publications to be sent with your branding. If you use Cooladata as a whitelabel site, all links can be updated to direct to that site. If not, they can be removed. Contact your CSM or email us at support@cooladata.com to set up.

Step 3 – Build your first dashboard

Create a new dashboard

  1. Open your workspace in the CoolaData Administrator console and select Dashboards 5-3.
  2. Click the Add + button. The following displays:
    GSSC 7
  3. Enter a name for the Dashboard and click Create. The new dashboard is displayed.
  4. To change the dashboard’s name, simply click the name and type over it.3-2

Add reports to the dashboard

  1. From the top right corner click the Add Reports button.
  2. Either choose Saved Reports to add an existing report, or New Report to create a new one. From here you can also add filters and descriptions to the sheet.
  3. To edit a report in a dashboard click the Edit button in the top right corner of the report. Note that you must have edit permission on the report to do this (only the report creator or project admin).
    3-9

 

Events will show up in the Dashboard within an hour or two of being received by CoolaData.

 

Share your Dashboard

The dashboard owner and editors can share a dashboard with anyone who has permission to the same projects. This gives them access to the dashboard and notifies them by email.

  1. In the dashboard, select Share GSSC 23 from the top right corner. The following panel opens:
    GSSC 21
  2. Copy the link and send it to anyone who already has permission to the dashboard to access it directly.
  3. In the Invite people field, select the people with whom to share this dashboard, and assign them View or Edit permissions. Only people who already have permission to the project can be invited to share your dashboard.
    • View: can see the dashboard and change the filter and date range for their own usage.
    • Edit: can make any change to the dashboard.
  4. Users who already have access to the dashboard are listed below – from here you can manage (change/remove) permission of users who already have access to the dashboard.

 

 

You can also

Add sheets

  1. Click on the Add + button to the right of the sheet tabs.
  2. Click on the down arrow to next to the sheet name to Rename, Duplicate or Delete it.

Set the dashboard date range

This timeframe applies to all reports in the dashboard unless the report is set to ignore external date range.

  1. Click the dates at the top right:  GSSC 18
  2. Select a timeframe for the Dashboard.

Set the dashboard filters

These filters apply to all reports in the dashboard unless the report is set to ignore external filters.
See more in Dashboard Filters.

  1. Click the Dashboard Filters 3-12 button at the top right.
  2. Set the desired filters and click apply.

Edit saved dashboards

You can open any dashboard you have permission on.
You can only edit/delete a dashboard if you are its owner, or if you were given editor permission on it.

  1. Open CoolaData and select Dashboards 5-3 – a list of the dashboards to which you have permission is displayed.
  2. Click any row to open the dashboard.
  3. To delete a dashboard click the row options and choose Delete, or from inside the dashboard open the dashboard option and choose Delete.

Unity

Setup

1. Download the tracker from: https://github.com/cooladata/cooladata-unity
2. Add the Unity package to your project.
3. Open the unity package with the unity IDE, or add the package as an asset to your project.
4. Add the following import to classes that use the CoolaData tracker:

using com.cooladata.tracking.sdk.unity;

5. Create and initialize the CoolaData tracker instance:

CoolaDataTracker.getInstance().setup(String appKey, String serviceEndPoint, String userId)

 

Tracking Events

After the CoolaData Tracker SDK is properly set up, you are ready to report events from your application. To start doing so, you need to call the trackEvent function with suitable parameters on every user’s action that you would like to track.

  • Prepare the parameters
Dictionary<string,string> myMap = new Dictionary<string, string>();
myMap.Add("unity param 1", "value1");
  • Add the event to the queue
CoolaDataTracker.getInstance().trackEvent("eventName", myMap);

Other event tracking examples:

CoolaDataTracker.getInstance().trackEvent(eventName, eventProperties);
CoolaDataTracker.getInstance().trackEvent(eventName, userId, eventProperties);
CoolaDataTracker.getInstance().trackEvent(eventName, eventProperties, eventId, callback);
CoolaDataTracker.getInstance().trackEvent(eventName, userId, eventProperties, eventId, callback);

Parameters Descriptions:

ParameterMandatoryDescription
eventNameYesThe name of the event to report.
userIdNoThe User ID relevant for this instance of the CoolaDataTracker. Can be provided either in the setup or the trackEvent method. If no userId is provided one will be generated automatically.
eventPropertiesNoThe custom properties to be sent with the event. This parameter is optional. The parameters should be in the Dictionary format.
eventIdNoAn ID of the event.
CallbackNoa CoolaDataDeliveryResult type result that will be returned when the data is sent.

iOS

Implementation

In order to start working with Cooladata JavaScript SDK follow the steps below:

Step 1 – Add Cooladata SDK to your project

Make sure that you are using the latest version of Xcode (5.0+), and targeting iOS 7.0 or higher. Demo project for Swift and Objective C can be found in our github repository: https://github.com/cooladata/pod.
Choose one of the following options to add the SDK to your project:

Option 1: Download the latest iOS SDK and import it (drag the cooladata-ios-sdk-X.X.X.framework to the framework’s folder in your project and select “Copy items to destination’s group folder”).

Option 2: Use CocoaPods:

  1. Create the Podfile
    • If this is your first Pod in your iOS project, create a file named Podfile:
      platform :ios, '7.0'
      use_frameworks!
      
      target 'MyApp' do
      pod 'CoolaPod', '~> 2.0.7'
      end
    • If you already use CocoaPods in your project, add a reference to CoolaData ‘s Pod:
      pod 'CoolaPod', '~> 2.0.7'
  2. Open the terminal app, change dir to your xcode project and run:
    $ pod install

    This command creates an xcode workspace for your project, and configures it to use CocoaPods.

  3. From now on, make sure to always open the Xcode workspace instead of the project file when building your project.

Step 2 – Initialization

Add the following import to the top of the AppDelegate.m file.

#import <cooladata-ios-sdk/CoolaDataTracker.h>

Add the following code inside the application:didFinishLaunchingWithOptions function.

[[CoolaDataTracker getInstance] setupWithAppKey:@"aknek0zuo8i4ztcmgopn5wotsceg80m9"];

Note: The CoolaDataTracker is a singleton. Its reference can be obtained by calling the getInstance method: [CoolaDataTracker getInstance]. Creating the new instance of the CoolaDataTracker object manually will cause an error; therefore do not call [CoolaDataTracker alloc] init].

Step 3 – Track Events

After the Cooladata Tracker SDK is properly set up, you are ready to report events from your application. To start doing so, you need to call the trackEvent function with suitable parameters on every users’ action that you would like to track.

// set properties on a dictionary
NSDictionary *properies = @{@"Type" : @"Female",
                                @"Amount" : @2, @"{u}Email":@"sam@email.com"};
    
// track event with properties
[[CoolaDataTracker getInstance] trackEvent:@"Add Item" properties:properties];

Full API Reference

setupWithApiToken

This method used to initialize a new CoolaData tracker object. Should be called only once from the application:didFinishLaunchingWithOptions.

NameTypeMandatoryDescription
appKeyNSStringYesThe AppKey provided by CoolaData.
serviceEndPointNSStringNoThe base URL for the CoolaData Tracker to use when accessing the CoolaData gateway.
userIdNSStringYesThe User ID of the current user. Mandatory in the setupWithApiToken function, or in the trackEvent function. I.e. if the User ID provided in the setupWithApiToken, there's no need to send User ID in the trackEvent function, and vice versa.
sessionIdNSStringNoThe Session ID relevant for this instance of the CoolaDataTracker.

CoolaDataDeliveryResult

This object will be returned from the callback function and contains the following.
Parameters

NameTypeDescription
eventIdNSStringThe ID of the event as specified in the track event.
statusBOOLThe status of the delivery. False or True.
deliveryStatusDescriptionNSStringThe description of the status state.
deliveryStatusCodeIntThe HTTP error code of the delivery attempt.
responsePropertiesNSDictionaryCustom properties to be sent with the event result.

trackEvent

Track user’ event

NameTypeMandatoryDescription
eventNameNSStringYesThe name of the event to report. This parameter is mandatory.
withEventIdNSStringNoThe Event ID relevant for this event. This parameter is optional. If response block is passed, event id must also be provided.
userIdNSStringNoThe User ID relevant for this event. This parameter is optional only if provided in the setup method. You must provide the userId either in the setup method or in the trackEvent method.
sessionIdNSStringNoThe Session ID relevant for this event. This parameter is optional.
optionalDataNSStringNoThe custom properties to be sent with the event. This parameter is optional.
errorNSErrorNoA pointer to an NSError object. It will be populated with an error in case an immediate  error occurs (mandatory parameter was not provided). This parameter is optional.
responseBlockBlockNoWhen calling the track event method, you can pass a response block that will be called with the result/error objects upon receive. For this to happen you must also pass an event id. You can pass the same event id for multiple events. All the blocks related to that event id will be called upon receipt of the related results. This parameter is optional.