snowplow-cpp-tracker/src/tracker.hpp at master · simoncl2/snowplow-cpp-tracker · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
/*
Copyright (c) 2016 Snowplow Analytics Ltd. All rights reserved.

This program is licensed to you under the Apache License Version 2.0,
and you may not use this file except in compliance with the Apache License Version 2.0.
You may obtain a copy of the Apache License Version 2.0 at http://www.apache.org/licenses/LICENSE-2.0.

Unless required by applicable law or agreed to in writing,
software distributed under the Apache License Version 2.0 is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the Apache License Version 2.0 for the specific language governing permissions and limitations there under.
*/

#ifndef TRACKER_H
#define TRACKER_H

#include <string>
#include "emitter.hpp"
#include "subject.hpp"
#include "client_session.hpp"
#include "self_describing_json.hpp"

using namespace std;

class Tracker {
public:
  static Tracker *init(Emitter &emitter, Subject *subject, ClientSession *client_session, string *platform, string *app_id, string *name_space, bool *use_base64);
  static Tracker *instance();
  static void close();

  class StructuredEvent {
  public:
    string category; // required
    string action; // required
    string *label;
    string *property;
    double *value;
    unsigned long long timestamp;
    string event_id;
    unsigned long long *true_timestamp;
    vector<SelfDescribingJson> contexts;
    StructuredEvent(string category, string action);
  };

  class SelfDescribingEvent {
  public:
    SelfDescribingJson event; // required
    unsigned long long timestamp;
    string event_id;
    unsigned long long *true_timestamp;
    vector<SelfDescribingJson> contexts;
    SelfDescribingEvent(SelfDescribingJson event);
  };

  class ScreenViewEvent {
  public:
    string *name;
    string *id;
    unsigned long long timestamp;
    string event_id;
    unsigned long long *true_timestamp;
    vector<SelfDescribingJson> contexts;
    ScreenViewEvent();
  };

  class TimingEvent {
  public:
    string category; // required
    string variable; // required
    unsigned long long timing; // required
    string *label;
    unsigned long long timestamp;
    string event_id;
    unsigned long long *true_timestamp;
    vector<SelfDescribingJson> contexts;
    TimingEvent(string category, string variable, unsigned long long timing);
  };

  void start();
  void stop();
  void flush();

  void set_subject(Subject *subject);

  void track(Payload p, const string & event_id, vector<SelfDescribingJson> &contexts);
  void track_struct_event(StructuredEvent);
  void track_screen_view(ScreenViewEvent);
  void track_timing(TimingEvent);
  void track_self_describing_event(SelfDescribingEvent);

private:
  static Tracker *m_instance;
  static mutex m_tracker_get;

  Tracker(Emitter &emitter, Subject *subject, ClientSession *client_session, string *platform, string *app_id, string *name_space, bool *use_base64);
  ~Tracker();

  Emitter &m_emitter;
  Subject *m_subject;
  ClientSession *m_client_session;
  string m_namespace;
  string m_app_id;
  string m_platform;
  bool m_use_base64;
};

#endif