Snowplow

https://docs.snowplow.io/docs/
Admin
Snowplow is an event analytics platform that provides SDKs, enrichment components, and data pipeline...
Tokens:898,471
Snippets:10,155
Trust Score:9.6
Update:2 months ago
Show doc for...
Tokens:
Raw
### Setup command examples

Source: https://docs.snowplow.io/docs/api-reference/snowplow-cli/reference

Basic usage examples for the setup command, including a read-only variant.

```text
$ snowplow-cli setup
```

```text
$ snowplow-cli setup --read-only
```

--------------------------------

### Automated CLI Setup

Source: https://docs.snowplow.io/docs/api-reference/snowplow-cli

Use the built-in setup command to guide you through device authentication and credential creation.

```bash
snowplow-cli setup
```

--------------------------------

### Initialize HTML5 media tracking via npm

Source: https://docs.snowplow.io/docs/sources/web-trackers/tracking-events/media/html5

Use this method when installing the plugin via npm, yarn, or pnpm. Requires importing the plugin and calling the start function after tracker initialization.

```javascript
import { newTracker, trackPageView } from '@snowplow/browser-tracker';

import { MediaTrackingPlugin, startHtml5MediaTracking } from '@snowplow/browser-plugin-media-tracking';



newTracker('sp1', '{{collector_url}}', {

   appId: 'my-app-id',

   plugins: [ MediaTrackingPlugin() ],

});



startHtml5MediaTracking(/* options */);
```

--------------------------------

### Setup command options

Source: https://docs.snowplow.io/docs/api-reference/snowplow-cli/reference

Configuration flags available for the setup command.

```text
  -S, --api-key string        Snowplow Console api key

  -a, --api-key-id string     Snowplow Console api key id

      --auth0-domain string   Auth0 domain (default "id.snowplowanalytics.com")

      --client-id string      Auth0 Client ID for device auth (default "EXQ3csSDr6D7wTIiebNPhXpgkSsOzCzi")

      --dotenv                Store as .env file in current working directory

  -h, --help                  help for setup

  -H, --host string           Snowplow Console host (default "https://console.snowplowanalytics.com")

  -m, --managed-from string   Link to a github repo where the data structure is managed

  -o, --org-id string         Your organization id

      --read-only             Create a read-only API key
```

--------------------------------

### Data-Products Release Examples

Source: https://docs.snowplow.io/docs/api-reference/snowplow-cli/reference

Examples of running the release command with default and custom directories.

```text
  $ snowplow-cli dp release

  $ snowplow-cli dp release ./my-data-products
```

--------------------------------

### Run setup command

Source: https://docs.snowplow.io/docs/api-reference/snowplow-cli/reference

Execute the setup command to initiate the device authentication flow.

```text
snowplow-cli setup [flags]
```

--------------------------------

### Clone and Start Snowplow Micro

Source: https://docs.snowplow.io/docs/testing/snowplow-micro/automated-testing

Commands to clone the example repository and initialize the environment using Docker Compose.

```bash
git clone https://github.com/snowplow-incubator/snowplow-micro-examples.git



cd snowplow-micro-examples



docker-compose up
```

--------------------------------

### Media Tracking Lifecycle

Source: https://docs.snowplow.io/docs/sources/flutter-tracker/tracking-events/media-tracking

This example demonstrates the complete lifecycle of media tracking, from starting a session to tracking various events and finally ending the session.

```APIDOC
## Media Tracking Lifecycle

### Description
This code snippet illustrates the typical flow for media tracking within a Flutter application.

### Method
`tracker.startMediaTracking`, `mediaTracking.update`, `mediaTracking.track`, `tracker.endMediaTracking`

### Code Example
```dart
// 1. Start tracking when player loads

final id = const Uuid().v4();

MediaTracking mediaTracking = await tracker.startMediaTracking(

  configuration: MediaTrackingConfiguration(

      id: id,

      player: const MediaPlayerEntity(

          duration: 300,

          label: 'My Video Title',

          mediaType: MediaType.video,

      )

  )

);



// 2. Update player state every second

await mediaTracking.update(

  player: MediaPlayerEntity(currentTime: currentTime)

);



// 3. Track events as they occur

await mediaTracking.track(MediaPlayEvent());
await mediaTracking.track(MediaPauseEvent());
await mediaTracking.track(MediaSeekStartEvent());
await mediaTracking.track(MediaSeekEndEvent());
await mediaTracking.track(MediaEndEvent());



// 4. End tracking when done

await tracker.endMediaTracking(id: id);
```
```

--------------------------------

### Validate Command Examples

Source: https://docs.snowplow.io/docs/api-reference/snowplow-cli/reference

Examples showing how to pass paths to the validation command.

```text
$ snowplow-cli dp validate ./data-products ./source-applications

  $ snowplow-cli dp validate ./src
```

--------------------------------

### Enable YouTube Tracking Example

Source: https://docs.snowplow.io/docs/sources/web-trackers/tracking-events/media/youtube

Full implementation example for enabling YouTube tracking with custom options.

```javascript
window.snowplow('enableYouTubeTracking', {

  id: 'example-video',

  options: {

    label: 'My Custom Video Label',

    captureEvents: ['play', 'pause', 'ended'],

    boundaries: [20, 80],

    updateRate: 500,

  }

})
```

```javascript
enableYouTubeTracking({

  id: 'example-video',

  options: {

    label: 'My Custom Video Label',

    captureEvents: ['play', 'pause', 'ended'],

    boundaries: [20, 80],

    updateRate: 200,

  }

})
```

--------------------------------

### Purge command examples

Source: https://docs.snowplow.io/docs/api-reference/snowplow-cli/reference

Examples of executing the purge command with default and custom directory paths.

```text
  $ snowplow-cli dp purge

  $ snowplow-cli dp purge ./my-data-products
```

--------------------------------

### Start, Update, and Track Media Events - Android (Java)

Source: https://docs.snowplow.io/docs/sources/mobile-trackers/tracking-events/media-tracking

Provides a Java example for the media tracking lifecycle on Android. Begin tracking when the player loads, update player state periodically, log media events, and end tracking when finished. Access the default tracker instance.

```java
// 1. Start tracking when player loads

String id = UUID.randomUUID().toString();

MediaPlayerEntity player = new MediaPlayerEntity();

player.setDuration(300.0);

player.setLabel("My Video Title");

player.setMediaType(MediaType.Video);



TrackerController tracker = Snowplow.getDefaultTracker();

MediaTracking mediaTracking = tracker.getMedia().startMediaTracking(id, player);



// 2. Update player state every second

MediaPlayerEntity update = new MediaPlayerEntity();

update.setCurrentTime(currentTime);

mediaTracking.update(update, null, null);



// 3. Track events as they occur

mediaTracking.track(new MediaPlayEvent(), null, null, null);

mediaTracking.track(new MediaPauseEvent(), null, null, null);

mediaTracking.track(new MediaSeekStartEvent(), null, null, null);

mediaTracking.track(new MediaSeekEndEvent(), null, null, null);

mediaTracking.track(new MediaEndEvent(), null, null, null);



// 4. End tracking when done

tracker.getMedia().endMediaTracking(id);
```

--------------------------------

### Desktop Context Example

Source: https://docs.snowplow.io/docs/sources/c-tracker/initialisation

An example of the data structure for the desktop context, which gathers extra device information.

```json
{

    "deviceManufacturer": "Apple Inc.",

    "deviceModel": "MacPro3,1",

    "deviceProcessorCount": 8,

    "osIs64Bit": true,

    "osServicePack": "",

    "osType": "macOS",

    "osVersion": "10.11.2"

}
```

--------------------------------

### Validate Data Structures Examples

Source: https://docs.snowplow.io/docs/api-reference/snowplow-cli/reference

Examples of running the validation command with default and custom paths.

```text
  $ snowplow-cli ds validate

  $ snowplow-cli ds validate ./my-data-structures ./my-other-data-structures
```

--------------------------------

### Example GET Request for Social Interaction

Source: https://docs.snowplow.io/docs/sources/webhooks/iglu-webhook

An example of an Iglu-compatible event sent via a GET request, including optional application ID and platform parameters.

```markup
http://{{COLLECTOR_URL}}/com.snowplowanalytics.iglu/v1?schema=iglu%3Acom.snowplowanalytics.snowplow%2Fsocial_interaction%2Fjsonschema%2F1-0-0

  &aid=mobile-attribution

  &p=mob

  &network=twitter

  &action=retweet
```

--------------------------------

### Manually start a new session (JavaScript tag)

Source: https://docs.snowplow.io/docs/sources/web-trackers/tracking-events/session

Use this method to manually expire the current session and start a new one, for example, after a user logs out.

```javascript
snowplow('newSession');
```

--------------------------------

### Install Enhanced Ecommerce Plugin (Browser NPM)

Source: https://docs.snowplow.io/docs/sources/web-trackers/tracking-events/ecommerce/enhanced

Instructions on how to install the enhanced ecommerce plugin using npm or yarn for browser-based projects, along with an example of initializing the tracker with the plugin.

```APIDOC
## Install Enhanced Ecommerce Plugin (Browser NPM)

**Browser (npm):**

- `npm install @snowplow/browser-plugin-enhanced-ecommerce`
- `yarn add @snowplow/browser-plugin-enhanced-ecommerce`
- `pnpm add @snowplow/browser-plugin-enhanced-ecommerce`

```javascript
import { newTracker, trackPageView } from '@snowplow/browser-tracker';
import { EnhancedEcommercePlugin, trackEnhancedEcommerceAction } from '@snowplow/browser-plugin-enhanced-ecommerce';

newTracker('sp1', '{{collector_url}}', {
   appId: 'my-app-id',
   plugins: [ EnhancedEcommercePlugin() ],
});
```
```

--------------------------------

### Start AVPlayer Media Tracking (iOS)

Source: https://docs.snowplow.io/docs/sources/mobile-trackers/tracking-events/media-tracking

Pass your AVPlayer instance and a media tracking configuration to start automatic event tracking. This setup enables the tracker to capture various playback events.

```swift
let mediaTracking = tracker.media.startMediaTracking(

    player: avPlayer,

    configuration: MediaTrackingConfiguration(id: "my-video")

)
```

--------------------------------

### Initialize Database

Source: https://docs.snowplow.io/docs/api-reference/iglu/iglu-repositories/iglu-server

Commands to create the PostgreSQL database and run the Iglu Server setup process.

```bash
psql -U postgres -c "CREATE DATABASE igludb"
```

```bash
docker run --rm \

-v $PWD/config.hocon:/iglu/config.hocon \

-e ACCEPT_LIMITED_USE_LICENSE=yes \

snowplow/iglu-server:0.14.1 setup --config /iglu/config.hocon
```

--------------------------------

### Install Go Analytics SDK

Source: https://docs.snowplow.io/docs/api-reference/analytics-sdk/analytics-sdk-go

Use 'go get' to add the Snowplow Analytics SDK for Go to your project.

```bash
go get github.com/snowplow/snowplow-golang-analytics-sdk
```

--------------------------------

### Initialize Emitter with Minimal Configuration

Source: https://docs.snowplow.io/docs/sources/golang-tracker/emitters

Initialize an emitter with the collector URI and a storage implementation. This is the most basic setup.

```go
emitter := sp.InitEmitter(RequireCollectorUri("com.acme"), sp.RequireStorage(*storagememory.Init()))
```

--------------------------------

### Converted Self-Describing JSON Event

Source: https://docs.snowplow.io/docs/sources/webhooks/iglu-webhook

The resulting self-describing JSON event after being processed by the Iglu webhook adapter from the example GET request.

```json
{

  "schema":"iglu:com.snowplowanalytics.snowplow/social_interaction/jsonschema/1-0-0",

  "data": {

    "network": "twitter",

    "action": "retweet"

  }

}
```

--------------------------------

### Verify enrichment startup logs

Source: https://docs.snowplow.io/docs/testing/snowplow-micro/local/enrichments

Example log output confirming that enrichments have been successfully enabled.

```text
[INFO] com.snowplowanalytics.snowplow.micro.Run - Downloading http://snowplow-hosted-assets.s3.amazonaws.com/third-party/maxmind/GeoLite2-City.mmdb...

[INFO] com.snowplowanalytics.snowplow.micro.Run - Enabled enrichments: IpLookupsEnrichment
```

--------------------------------

### Quick Start Media Tracking Lifecycle

Source: https://docs.snowplow.io/docs/sources/flutter-tracker/tracking-events/media-tracking

Demonstrates the four main steps of media tracking: starting, updating player state, tracking events, and ending the session. Ensure you have the Uuid package for ID generation.

```dart
final id = const Uuid().v4();

MediaTracking mediaTracking = await tracker.startMediaTracking(

  configuration: MediaTrackingConfiguration(

      id: id,

      player: const MediaPlayerEntity(

          duration: 300,

          label: 'My Video Title',

          mediaType: MediaType.video,

      )

  )

);



// 2. Update player state every second

await mediaTracking.update(

  player: MediaPlayerEntity(currentTime: currentTime)

);



// 3. Track events as they occur

await mediaTracking.track(MediaPlayEvent());
await mediaTracking.track(MediaPauseEvent());
await mediaTracking.track(MediaSeekStartEvent());
await mediaTracking.track(MediaSeekEndEvent());
await mediaTracking.track(MediaEndEvent());



// 4. End tracking when done

await tracker.endMediaTracking(id: id);
```

--------------------------------

### Run Snowtype executable

Source: https://docs.snowplow.io/docs/event-studio/implement-tracking/install-snowtype

Execute the locally installed Snowtype CLI to view available commands and options. This example uses npx, but yarn or pnpm can also be used.

```bash
npx snowtype --help
```

--------------------------------

### Initialize Tracker with Ecommerce Plugin (npm)

Source: https://docs.snowplow.io/docs/sources/web-trackers/tracking-events/ecommerce

Initialize the Snowplow tracker with the ecommerce plugin when installing via npm. This example shows the import and configuration for a new tracker instance.

```javascript
import { newTracker } from '@snowplow/browser-tracker';

import { SnowplowEcommercePlugin } from '@snowplow/browser-plugin-snowplow-ecommerce';



newTracker('sp1', '{{collector_url}}', {

   appId: 'my-app-id',

   plugins: [ SnowplowEcommercePlugin() ],

});
```

--------------------------------

### Generate Source Apps and Tracking Plans

Source: https://docs.snowplow.io/docs/api-reference/snowplow-cli/reference

Example command to generate multiple source applications and a tracking plan.

```text
  $ snowplow-cli dp generate --source-app "Mobile app" --source-app "Web app" --data-product "Signup flow"
```

--------------------------------

### Start Element Tracking with Browser Plugin (npm)

Source: https://docs.snowplow.io/docs/sources/web-trackers/tracking-events/element-tracking

Install and use the element tracking plugin via npm for your browser-based JavaScript applications. This provides a modular way to add element tracking functionality.

```javascript
import { startElementTracking } from '@snowplow/browser-plugin-element-tracking';



startElementTracking({

  elements: [

    {

      selector: ".blogs_blog-post-body_content",

      name: "blog content",

      expose: false,

      includeStats: ["page_ping"]

    },

    {

      selector: ".blogs_blog-post-body_content p",

      name: "blog paragraphs"

    }

  ]

});
```

--------------------------------

### Initialize Emitter with Full Configuration

Source: https://docs.snowplow.io/docs/sources/golang-tracker/emitters

Initialize an emitter with all available options, including request type, protocol, send limits, byte limits, and a custom callback function for delivery status.

```go
emitter := sp.InitEmitter(

  sp.RequireCollectorUri("com.acme"),

  sp.RequireStorage(*storagememory.Init()),

  sp.OptionRequestType("GET"),

  sp.OptionProtocol("https"),

  sp.OptionSendLimit(50),

  sp.OptionByteLimitGet(52000),

  sp.OptionByteLimitPost(52000),

  sp.OptionCallback(func(g []CallbackResult, b []CallbackResult) {

    log.Println("Successes: " + IntToString(len(g)))

    log.Println("Failures: " + IntToString(len(b)))

  }),

)
```

--------------------------------

### Add Context Entities to Screen View (npm)

Source: https://docs.snowplow.io/docs/sources/webview-tracker

Add context entities to a screen view event when installed via npm. This example adds two custom entities for movie poster and customer data.

```javascript
trackScreenView({

      id: '2c295365-eae9-4243-a3ee-5c4b7baccc8f',

      context: [

        {

          schema: 'iglu:com.my_company/movie_poster/jsonschema/1-0-0',

          data: {

            movie_name: 'Solaris',

            poster_country: 'JP',

            poster_date: '1978-01-01',

          },

        },

        {

          schema: 'iglu:com.my_company/customer/jsonschema/1-0-0',

          data: {

            p_buy: 0.23,

            segment: 'young_adult',

          },

        },

      ],

    });
```

--------------------------------

### Run Micro with Iglu registry configuration

Source: https://docs.snowplow.io/docs/testing/snowplow-micro/local/schemas

Start the Micro container while passing environment variables for the Iglu registry URL and API key.

```bash
 export MICRO_IGLU_REGISTRY_URL=https://com-example.iglu.snplow.net/api

export MICRO_IGLU_API_KEY=abcdef123456





docker run -p 9090:9090 \

-e MICRO_IGLU_REGISTRY_URL \

-e MICRO_IGLU_API_KEY \

snowplow/snowplow-micro:4.4.0
```

--------------------------------

### startYouTubeTracking(id, video, options)

Source: https://docs.snowplow.io/docs/sources/web-trackers/tracking-events/media/youtube

Initializes tracking for a YouTube player instance. This function installs the necessary iFrame API, sets up event listeners, and returns a unique media session ID.

```APIDOC
## startYouTubeTracking(id, video, options)

### Description
Begins auto-tracking a YouTube Player instance. It installs the iFrame API if necessary, adds event listeners, and configures poll intervals.

### Parameters
- **id** (string) - Required - A unique session UUID for each media element.
- **video** (VideoLocation) - Required - A DOM ID for the iFrame, an iFrame element, or a YT.Player instance.
- **label** (string) - Optional - A custom human-readable label for the media element.
- **captureEvents** (CapturableEvents[]) - Optional - A list of media events to track.
- **boundaries** (number[]) - Optional - Percentage thresholds (0-100) to trigger progress events.
- **context** (DynamicContext) - Optional - Dynamic contexts attached to each tracking event.
- **updatePageActivityWhilePlaying** (boolean) - Optional - Whether to update page activity while media is playing.
- **filterOutRepeatedEvents** (FilterOutRepeatedEvents) - Optional - Whether to suppress consecutive identical events.

### Returns
- **mediaSessionId** (string) - The unique ID used for generated events.
```

--------------------------------

### Inline Plugin: Add Context Entities (NPM)

Source: https://docs.snowplow.io/docs/sources/web-trackers/plugins/creating-your-own-plugins

Shows how to define and add an inline plugin using the Snowplow JavaScript Tracker when installed via NPM. This example adds a custom context entity to all events.

```javascript
import { addPlugin } from '@snowplow/browser-tracker';



const myPlugin = {

  contexts: () => {

    return [

      {

        schema: 'iglu:com.acme/my_context/jsonschema/1-0-0',

        data: {

          property: 'value',

        },

      },

    ];

  },

};



addPlugin(myPlugin, ['sp1'])
```

--------------------------------

### Start Element Tracking with Components (Browser Plugin)

Source: https://docs.snowplow.io/docs/sources/web-trackers/tracking-events/element-tracking

Use this to mark elements as components and track other elements within them. Events for child elements will include a `component_parents` entity listing their ancestor components. Requires installation of `@snowplow/browser-plugin-element-tracking`.

```javascript
import { SnowplowElementTrackingPlugin, startElementTracking } from '@snowplow/browser-plugin-element-tracking';



startElementTracking({

  elements: [

    // Define components (containers)

    {

      selector: 'header', // Mark the header as a component

      name: 'site_header',

      component: true,

      expose: false // Don't track expose events for the component itself

    },

    {

      selector: 'footer', // Mark the footer as a component

      name: 'site_footer',

      component: true,

      expose: false // Don't track expose events for the component itself

    },

    // Track elements - events will include component_parents

    {

      selector: '.newsletter-form',

      name: 'newsletter_signup',

      create: true, // Fire create_element events

      expose: { when: 'element' } // Fire expose_element events

    }

  ]

});
```

--------------------------------

### Initialize and Start .NET Tracker

Source: https://docs.snowplow.io/docs/sources/net-tracker/tracker

Configure the .NET tracker instance with emitter, subject, session, and logging options. Ensure to dispose of storage manually after stopping the tracker.

```csharp
var logger = new ConsoleLogger();

var endpoint = new SnowplowHttpCollectorEndpoint(emitterUri, method: method, port: port, protocol: protocol, l: logger);

var storage = new LiteDBStorage("events.db");

var queue = new PersistentBlockingQueue(storage, new PayloadToJsonString());

var emitter = new AsyncEmitter(endpoint, queue, l: logger);

var subject = new Subject().SetPlatform(Platform.Mob).SetLang("EN");

var session = new ClientSession("client_session.dict", l: logger);



Tracker.Instance.Start(emitter: emitter, subject: subject, clientSession: session, trackerNamespace: "some namespace", appId: "some appid", encodeBase64: true, l: logger);
```

--------------------------------

### Run Stream Collector with TLS Enabled

Source: https://docs.snowplow.io/docs/api-reference/stream-collector/configure

Start the Snowplow Scala Stream Collector in a Docker container, mounting configuration and SSL directories. This example configures the collector to use the generated PKCS12 certificate for TLS on port 8443.

```bash
config_dir=/opt/snowplow/config


docker run \
  -d \
  --name scala-stream-collector \
  --restart always \
  --network host \
  -v ${config_dir}:/snowplow/config \
  -v ${ssl_dir}:/snowplow/ssl \
  -p 8080:8080 \
  -p 8443:8443 \
  -e 'JAVA_OPTS=-Xms2g -Xmx2g -Djavax.net.ssl.keyStoreType=pkcs12 -Djavax.net.ssl.keyStorePassword=changeme -Djavax.net.ssl.keyStore=/snowplow/ssl/collector.p12 -Dorg.slf4j.simpleLogger.defaultLogLevel=warn -Dcom.amazonaws.sdk.disableCbor' \
  snowplow/scala-stream-collector-kinesis:2.5.0 \
  --config /snowplow/config/snowplow-stream-collector-kinesis-2.5.0.hocon
```

--------------------------------

### Start MCP Server

Source: https://docs.snowplow.io/docs/api-reference/snowplow-cli/reference

Command to initiate the MCP stdio server.

```text
snowplow-cli mcp [flags]
```

--------------------------------

### Example Configuration File

Source: https://docs.snowplow.io/docs/modeling-your-data/modeling-your-data-with-dbt/dbt-models/dbt-normalize-data-model

A JSON configuration file defining event filtering, context schemas, and user table settings for the normalization process.

```json
{

    "config":{

        "resolver_file_path": "utils/example_resolver_config.json",

        "filtered_events_table_name":"snowplow_events_normalized",

        "users_table_name":"snowplow_context_users",

        "validate_schemas": true,

        "overwrite": true,

        "models_folder": "snowplow_normalized_events",

        "models_prefix": "snowplow"

    },

    "events":[

        {

            "event_names": ["page_view", "page_ping"],

            "event_columns": [

                "domain_userid",

                "app_id",

                "load_tstamp",

                "page_url"

            ],

            "context_schemas":[

                "iglu:com.snowplowanalytics.snowplow/web_page/jsonschema/1-0-0",

                "iglu:nl.basjes/yauaa_context/jsonschema/1-0-4"

            ],

            "context_aliases": ["page", "yauaa"],

            "table_name": "snowplow_page_events",

            "version": "1"

        },

        {

            "event_names": ["link_click"],

            "event_columns": [

                "domain_userid",

                "app_id",

                "refr_urlpath"

            ],

            "self_describing_event_schemas": ["iglu:com.snowplowanalytics.snowplow/link_click/jsonschema/1-0-1"],

            "self_describing_event_aliases": ["click"],

            "context_schemas":[

                "iglu:com.snowplowanalytics.snowplow/ua_parser_context/jsonschema/1-0-0"

            ]

        }

    ],

    "users":{

        "user_id": {

            "id_column": "userId",

            "id_self_describing_event_schema": "iglu:com.google.analytics.measurement-protocol/user/jsonschema/1-0-0",

            "id_context_schema": "iglu:com.zendesk.snowplow/user/jsonschema/1-0-0",

            "alias": "true_user_id"

        },

        "user_contexts": ["iglu:com.snowplowanalytics.snowplow/ua_parser_context/jsonschema/1-0-0",

            "iglu:com.iab.snowplow/spiders_and_robots/jsonschema/1-0-0"],

        "user_columns": [

            "domain_userid",

            "network_userid",

            "app_id"

        ]

    }

}
```

--------------------------------

### Tracker Start

Source: https://docs.snowplow.io/docs/sources/net-tracker/tracker

The `Start(...)` function must be called before any events will start being stored or sent. This function starts the background emitter thread and the background session check timer (if optional).

```APIDOC
## Start(...)

### Description

This function must be called before any events will start being stored or sent. This is due to the fact that we do not want to start any background processing from the constructors so it is left up to the developer to choose when to start everything up.

If you attempt to access the Tracker singleton before Starting it an exception will be thrown.

This function:

- Starts the background emitter thread
- Starts the background session check timer (Optional)

Once this is run everything should be in place for asynchronous event tracking.

### Parameters

#### Path Parameters

- **emitter** (Emitter) - Required - The Emitter object you create.
- **subject** (Subject) - Optional - The Subject that defines a user.
- **clientSession** (Session) - Optional - The Session object you create.
- **trackerNamespace** (string) - Optional - The name of the tracker instance.
- **appId** (string) - Optional - The application ID.
- **encodeBase64** (bool) - Optional - If we base 64 encode JSON values.
- **l** (Logger) - Optional - The logger to use within the application.
```

--------------------------------

### Initialize Terraform and Plan Changes for Iglu Server

Source: https://docs.snowplow.io/docs/get-started/self-hosted/upgrade-guide

Navigate to the Iglu Server Terraform configuration directory and run 'terraform init' to initialize the backend and download providers. 'terraform plan' will show the infrastructure changes before applying them.

```bash
cd terraform/aws/iglu_server/default

terraform init

terraform plan
```

--------------------------------

### Data-Products Download Examples

Source: https://docs.snowplow.io/docs/api-reference/snowplow-cli/reference

Common usage patterns for the download command.

```text
$ snowplow-cli dp download

  $ snowplow-cli dp download ./my-data-products
```

--------------------------------

### SQL Query Example

Source: https://docs.snowplow.io/docs/pipeline/enrichments/available-enrichments/custom-sql-enrichment

Example SQL query used for enrichment.

```sql
SELECT username, date_of_birth FROM tbl_users WHERE user = 123;

| username | date_of_birth |

| -------- | ------------- |

| karl     | 1980-06-12    |
```

--------------------------------

### Install localtunnel

Source: https://docs.snowplow.io/docs/testing/snowplow-micro/local/remote-usage

Global installation command for the localtunnel CLI tool.

```bash
npm install -g localtunnel
```

--------------------------------

### Configuration for startMediaTracking

Source: https://docs.snowplow.io/docs/sources/web-trackers/tracking-events/media/snowplow

Details on how to configure player properties when initiating media tracking.

```APIDOC
## Configuration

Configure media tracking when you call `startMediaTracking`. All configuration is optional.

### Player properties

Set initial player properties to populate the [media player entity](/docs/events/ootb-data/media-events/#media-player). The `label` property is recommended as it helps identify content during analysis.

**JavaScript (tag):**
```javascript
window.snowplow('startMediaTracking', {
  id,
  player: {
      currentTime: 0,          // Current playback position in seconds
      duration: 300,           // Total duration in seconds
      ended: false,            // Whether playback has ended
      livestream: false,       // Whether this is a live stream
      label: 'My Video',       // Human-readable title (recommended)
      loop: false,             // Whether to restart after ending
      mediaType: 'video',      // 'video' or 'audio'
      muted: false,            // Whether audio is muted
      paused: true,            // Whether playback is paused
      pictureInPicture: false, // Whether in picture-in-picture mode
      playerType: 'html5',     // Player type identifier
      playbackRate: 1.0,       // Playback speed (1 = normal)
      quality: '1080p',        // Quality level
      volume: 100              // Volume percentage (0-100)
  }
});
```

**Browser (npm):**
```javascript
import { startMediaTracking, MediaType } from "@snowplow/browser-plugin-media";

startMediaTracking({
  id,
  player: {
      currentTime: 0,          // Current playback position in seconds
      duration: 300,           // Total duration in seconds
      ended: false,            // Whether playback has ended
      livestream: false,       // Whether this is a live stream
      label: 'My Video',       // Human-readable title (recommended)
      loop: false,             // Whether to restart after ending
      mediaType: MediaType.Video, // MediaType.Video or MediaType.Audio
      muted: false,            // Whether audio is muted
      paused: true,            // Whether playback is paused
      pictureInPicture: false, // Whether in picture-in-picture mode
      playerType: 'html5',     // Player type identifier
      playbackRate: 1.0,       // Playback speed (1 = normal)
      quality: '1080p',        // Quality level
      volume: 100              // Volume percentage (0-100)
  }
});
```
```

--------------------------------

### Initialize Snowtype project

Source: https://docs.snowplow.io/docs/event-studio/implement-tracking/install-snowtype

Initialize your Snowtype project by running the `init` command. This will create a configuration file and prompt you for necessary details like organization ID, tracker, language, and output path.

```bash
npx snowtype init
```

--------------------------------

### Install Snowplow Ecommerce Plugin via npm/yarn/pnpm

Source: https://docs.snowplow.io/docs/collecting-data/collecting-from-own-applications/javascript-trackers/web-tracker/plugins/snowplow-ecommerce

Install the Snowplow Ecommerce plugin using your preferred package manager. This is for use with the browser tracker when installed via npm.

```javascript
import { newTracker } from '@snowplow/browser-tracker';
import { SnowplowEcommercePlugin } from '@snowplow/browser-plugin-snowplow-ecommerce';

newTracker('sp1', '{{collector_url}}', {
   appId: 'my-app-id',
   plugins: [ SnowplowEcommercePlugin() ],
});
```

--------------------------------

### Igluctl configuration file example

Source: https://docs.snowplow.io/docs/api-reference/iglu/igluctl

A HOCON configuration file defining linting rules, generation settings, and deployment actions.

```json
  {

    "lint": {

      "skipWarnings": true

      "includedChecks": [

        "rootObject"

        "unknownFormats"

        "numericMinMax"

        "stringLength"

        "optionalNull"

        "description"

        "stringMaxLengthRange"

      ]

    }



    "generate": {

      "dbschema": "atomic"

      "force": false

    }





    "actions": [

      {

        "action": "push"

        "isPublic": true

        "apikey": "bd96b5ff-7eb7-4085-83e0-97ac4954b891"

        "apikey": ${APIKEY_1}

      }

      {

        "action": "s3cp"

        "uploadFormat": "jsonschema"

        "profile": "profile-1"

        "region": "eu-east-2"

      }

    ]



}
```

--------------------------------

### Direct Tracker, Emitter, and ClientSession Initialization

Source: https://docs.snowplow.io/docs/sources/c-tracker/initialisation

Instantiate and configure storage, emitter, subject, client session, and tracker components directly. This approach is suitable for custom implementations or when fine-grained control is needed.

```cpp
#include <snowplow/snowplow.hpp>



// 1. create storage for event queue and session information

auto storage = std::make_shared<SqliteStorage>("sp.db");

// 2. create an emitter for sending event to Snowplow collector

auto emitter = std::make_shared<Emitter>(storage, "com.acme.collector");

// 3. create a subject with user and device information

auto subject = std::make_shared<Subject>();

subject->set_user_id("a-user-id");

// 4. optionally create a client_session for session tracking

auto client_session = std::make_shared<ClientSession>(storage, 5000, 5000);

// 5. finally, create the tracker instance

auto tracker = std::make_shared<Tracker>(emitter, subject, client_session, "pc", "app_id", "ns");
```

--------------------------------

### Install Snowplow Tracker with LuaRocks

Source: https://docs.snowplow.io/docs/sources/lua-tracker

Install the Snowplow tracker using LuaRocks. Ensure Lua, LuaRocks, and curl are installed. You may need to specify the CURL_DIR if curl is not found automatically.

```bash
luarocks install snowplowtracker
```

```bash
luarocks install snowplowtracker CURL_DIR=/usr/local/Cellar/curl/7.82.0/
```

--------------------------------

### Initialize Tracker with Optional Configurations

Source: https://docs.snowplow.io/docs/sources/golang-tracker/initialization

Initialize a tracker with optional configurations including subject, namespace, app ID, platform, and base64 encoding.

```go
subject := sp.InitSubject()

emitter := sp.InitEmitter(
  sp.RequireCollectorUri("com.acme"),
  sp.RequireStorage(*storagememory.Init()),
)

tracker := sp.InitTracker(
  sp.RequireEmitter(emitter),
  sp.OptionSubject(subject),
  sp.OptionNamespace("namespace"),
  sp.OptionAppId("app-id"),
  sp.OptionPlatform("mob"),
  sp.OptionBase64Encode(false),
)
```

--------------------------------

### Create Catalog and Schema

Source: https://docs.snowplow.io/docs/get-started/self-hosted/quick-start

SQL commands to initialize the schema for the loader. Replace placeholders with your specific catalog and schema names.

```sql
-- USE CATALOG ${catalog_name}; -- Uncomment if your want to use a custom Unity catalog and replace with your own value.



CREATE SCHEMA IF NOT EXISTS ${schema_name}

-- LOCATION s3://<custom_location>/ -- Uncomment if you want tables created by Snowplow to be located in a non-default bucket or directory.

;
```

--------------------------------

### Install Signals Python SDK

Source: https://docs.snowplow.io/docs/signals/connection

Install the required package via pip.

```bash
pip install snowplow-signals
```

--------------------------------

### YAUAA Context Entity Example

Source: https://docs.snowplow.io/docs/enriching-your-data/available-enrichments/yauaa-enrichment

Example of the data structure generated by the YAUAA enrichment.

```json
{

  "deviceClass": "Phone",

  "deviceName": "Samsung SM-G960F",

  "deviceBrand": "Samsung",

  "operatingSystemClass": "Mobile",

  "operatingSystemName": "Android",

  "operatingSystemVersion": "8.0.0",

  "operatingSystemNameVersion": "Android 8.0.0",

  "operatingSystemVersionBuild": "R16NW",

  "layoutEngineClass": "Browser",

  "layoutEngineName": "Blink",

  "layoutEngineVersion": "62.0",

  "layoutEngineVersionMajor": "62",

  "layoutEngineNameVersion": "Blink 62.0",

  "layoutEngineNameVersionMajor": "Blink 62",

  "agentClass": "Browser",

  "agentName": "Chrome",

  "agentVersion": "62.0.3202.84",

  "agentVersionMajor": "62",

  "agentNameVersion": "Chrome 62.0.3202.84",

  "agentNameVersionMajor": "Chrome 62"

}
```

--------------------------------

### Install NPM Dependencies

Source: https://docs.snowplow.io/docs/testing/snowplow-micro/automated-testing

Command to install the required testing frameworks, Nightwatch and Cypress.

```bash
npm install
```

--------------------------------

### Start Element Tracking (npm)

Source: https://docs.snowplow.io/docs/sources/web-trackers/tracking-events/element-tracking

After initializing the tracker with the plugin, call startElementTracking to begin monitoring elements based on your defined rules.

```javascript
startElementTracking({ elements: [/* configuration */] });
```

--------------------------------

### View Snowplow Micro startup logs

Source: https://docs.snowplow.io/docs/testing/snowplow-micro/local

Example output indicating that the Micro HTTP server has successfully bound to the specified port.

```text
[INFO] com.snowplowanalytics.snowplow.micro.Run - No enrichments enabled

[INFO] com.snowplowanalytics.snowplow.micro.MicroHttpServer - Building blaze server

[INFO] org.http4s.blaze.channel.nio1.NIO1SocketServerGroup - Service bound to address /[0:0:0:0:0:0:0:0]:9090
```

--------------------------------

### Create Tracker with All Arguments

Source: https://docs.snowplow.io/docs/sources/php-tracker/initialization

Initialize a Tracker instance using all available arguments: emitter, subject, namespace, application ID, and base64 encoding preference.

```php
$tracker = new Tracker($emitter, $subject, "cf", "cf29ea", true);
```

--------------------------------

### Install Nightwatch and ChromeDriver

Source: https://docs.snowplow.io/docs/testing/snowplow-micro/automated-testing

Install the necessary dependencies for Nightwatch.js and the Chrome driver as development dependencies.

```bash
npm install nightwatch --save-dev

npm install chromedriver --save-dev
```

--------------------------------

### Data Structures Download Examples

Source: https://docs.snowplow.io/docs/api-reference/snowplow-cli/reference

Common usage patterns for the download command, including filtering and output configuration.

```text
$ snowplow-cli ds download
```

```text
$ snowplow-cli ds download --match com.example/event_name --match com.example.subdomain
```

```text
$ snowplow-cli ds download --output-format json ./my-data-structures
```

```text
$ snowplow-cli ds download --include-legacy
```

--------------------------------

### Install Node.js tracker with yarn

Source: https://docs.snowplow.io/docs/sources/node-js-tracker/initialization

Use this command to install the tracker package via yarn.

```bash
yarn add @snowplow/node-tracker
```

--------------------------------

### Initialize Tracker with Emitter and Storage

Source: https://docs.snowplow.io/docs/sources/golang-tracker/initialization

Create a basic tracker instance by initializing an emitter with a collector URI and an in-memory storage implementation.

```go
import storagememory "github.com/snowplow/snowplow-golang-tracker/v3/pkg/storage/memory"

import sp "github.com/snowplow/snowplow-golang-tracker/v3/tracker"


emitter := sp.InitEmitter(sp.RequireCollectorUri("com.acme"), sp.RequireStorage(*storagememory.Init()))

tracker := sp.InitTracker(sp.RequireEmitter(emitter))
```

--------------------------------

### Sync Data Products Examples

Source: https://docs.snowplow.io/docs/api-reference/snowplow-cli/reference

Common usage patterns for the sync command, including default and custom directory paths.

```text
  $ snowplow-cli dp sync

  $ snowplow-cli dp sync ./my-data-products
```

--------------------------------

### Install Node.js tracker with pnpm

Source: https://docs.snowplow.io/docs/sources/node-js-tracker/initialization

Use this command to install the tracker package via pnpm.

```bash
pnpm add @snowplow/node-tracker
```

--------------------------------

### Install Node.js tracker with npm

Source: https://docs.snowplow.io/docs/sources/node-js-tracker/initialization

Use this command to install the tracker package via npm.

```bash
npm install @snowplow/node-tracker
```
Tokens:
Raw