550 lines
18 KiB
PHP
550 lines
18 KiB
PHP
<?php
|
|
/**
|
|
* Plugin Name: Simplified Tracking Plugin
|
|
* Description: Adds tracking script to website header and tracks user interactions
|
|
* Version: 1.2.0
|
|
* Author: Karl Breuer
|
|
* Text Domain: simple-tracking
|
|
*/
|
|
|
|
// Exit if accessed directly
|
|
if (!defined('ABSPATH')) {
|
|
exit;
|
|
}
|
|
|
|
class Simplified_Tracking_Plugin {
|
|
|
|
// Plugin instance
|
|
private static $instance = null;
|
|
|
|
// Tracking server URL
|
|
private $tracking_server_url = 'tracking1.karlbreuer.com';
|
|
|
|
/**
|
|
* Constructor
|
|
*/
|
|
private function __construct() {
|
|
// Add the script to the header
|
|
add_action('wp_head', array($this, 'add_tracking_script'), 10);
|
|
|
|
// Register the endpoint
|
|
add_action('init', array($this, 'register_tracking_endpoint'));
|
|
|
|
// Add settings page
|
|
add_action('admin_menu', array($this, 'add_settings_page'));
|
|
add_action('admin_init', array($this, 'register_settings'));
|
|
|
|
// Add focused tracking for elements with specific classes
|
|
add_action('wp_footer', array($this, 'add_class_tracking_script'), 99);
|
|
|
|
// Add shortcode for manual tracking
|
|
add_shortcode('track_element', array($this, 'tracking_shortcode'));
|
|
|
|
// Register custom block for Gutenberg
|
|
add_action('init', array($this, 'register_tracking_block'));
|
|
}
|
|
|
|
/**
|
|
* Get plugin instance
|
|
*/
|
|
public static function get_instance() {
|
|
if (null === self::$instance) {
|
|
self::$instance = new self();
|
|
}
|
|
return self::$instance;
|
|
}
|
|
|
|
/**
|
|
* Add tracking script to header
|
|
*/
|
|
public function add_tracking_script() {
|
|
$server_url = esc_url(get_option('simple_tracking_server_url', $this->tracking_server_url));
|
|
?>
|
|
<!-- Global server config -->
|
|
<script> const server = "https://<?php echo $server_url; ?>";</script>
|
|
<!-- Tracking function -->
|
|
<script>
|
|
// Initialize tracking function
|
|
function tE(eventName, additionalParams = {}) {
|
|
// Create tracking data object
|
|
const data = {
|
|
event: eventName,
|
|
url: window.location.href,
|
|
ref: document.referrer,
|
|
ua: navigator.userAgent,
|
|
sw: window.screen.width,
|
|
lang: navigator.language || navigator.userLanguage,
|
|
};
|
|
|
|
// Add any additional parameters
|
|
Object.assign(data, additionalParams);
|
|
|
|
// Helper function to serialize an object into URL parameters
|
|
function serializeObject(obj, prefix) {
|
|
const str = [];
|
|
for (const p in obj) {
|
|
if (obj.hasOwnProperty(p)) {
|
|
const k = prefix ? prefix + "[" + p + "]" : p;
|
|
const v = obj[p];
|
|
if (v !== null && typeof v === "object") {
|
|
str.push(serializeObject(v, k));
|
|
} else {
|
|
str.push(encodeURIComponent(k) + "=" + encodeURIComponent(v));
|
|
}
|
|
}
|
|
}
|
|
return str.join("&");
|
|
}
|
|
|
|
// Function for sending tracking data
|
|
function sendInfo() {
|
|
try {
|
|
// Send to our WordPress endpoint first, which will forward to the tracking server
|
|
const siteUrl = window.location.origin;
|
|
const trackingUrl = `${siteUrl}/track?${serializeObject(data)}`;
|
|
fetch(trackingUrl, {
|
|
method: "POST",
|
|
mode: "no-cors",
|
|
cache: "no-cache",
|
|
credentials: "omit", // Don't send cookies
|
|
headers: {
|
|
"X-Final-Destination": server // Pass the final destination
|
|
},
|
|
keepalive: true, // Ensures request completes even if page unloads
|
|
});
|
|
return true;
|
|
} catch (e) {
|
|
console.error("Tracking error:", e);
|
|
}
|
|
}
|
|
|
|
return sendInfo();
|
|
}
|
|
</script>
|
|
<!-- Set up page load tracking -->
|
|
<script>
|
|
document.addEventListener("DOMContentLoaded", function() {
|
|
try {
|
|
tE("pageload");
|
|
} catch (error) {
|
|
console.error("Error in page load tracking:", error);
|
|
}
|
|
});
|
|
</script>
|
|
<?php
|
|
}
|
|
|
|
/**
|
|
* Add JavaScript to track elements with specific classes
|
|
*/
|
|
public function add_class_tracking_script() {
|
|
// Get custom elements to track
|
|
$track_classes = get_option('simple_tracking_track_classes', '');
|
|
$track_classes_array = array_filter(array_map('trim', explode(',', $track_classes)));
|
|
|
|
if (empty($track_classes_array)) {
|
|
return;
|
|
}
|
|
|
|
?>
|
|
<!-- Simplified class-based tracking script -->
|
|
<script>
|
|
document.addEventListener('DOMContentLoaded', function() {
|
|
// Helper function to get element details for tracking
|
|
function getElementDetails(element) {
|
|
const details = {};
|
|
|
|
// Get element text or alternative
|
|
if (element.textContent && element.textContent.trim()) {
|
|
details.text = element.textContent.trim();
|
|
} else if (element.placeholder) {
|
|
details.text = element.placeholder;
|
|
} else if (element.value) {
|
|
details.text = element.value;
|
|
} else if (element.alt) {
|
|
details.text = element.alt;
|
|
} else if (element.getAttribute('aria-label')) {
|
|
details.text = element.getAttribute('aria-label');
|
|
}
|
|
|
|
// Limit text length
|
|
if (details.text && details.text.length > 50) {
|
|
details.text = details.text.substring(0, 47) + '...';
|
|
}
|
|
|
|
// Get element ID, class and href if available
|
|
if (element.id) {
|
|
details.id = element.id;
|
|
}
|
|
|
|
if (element.className) {
|
|
details.class = element.className;
|
|
}
|
|
|
|
if (element.href) {
|
|
const href = element.href;
|
|
// Only include if it's not too long
|
|
if (href.length < 100) {
|
|
details.href = href;
|
|
}
|
|
}
|
|
|
|
return details;
|
|
}
|
|
|
|
<?php foreach ($track_classes_array as $class) : ?>
|
|
// Track elements with class: <?php echo esc_js($class); ?>
|
|
const <?php echo str_replace('-', '_', sanitize_key($class)); ?>Elements = document.querySelectorAll('.<?php echo esc_js($class); ?>');
|
|
<?php echo str_replace('-', '_', sanitize_key($class)); ?>Elements.forEach(function(element) {
|
|
element.addEventListener('click', function(e) {
|
|
const details = getElementDetails(element);
|
|
tE('custom_element_click', { element: 'custom', class: '<?php echo esc_js($class); ?>', ...details });
|
|
});
|
|
});
|
|
<?php endforeach; ?>
|
|
|
|
// Track elements with data-track attribute
|
|
const trackedElements = document.querySelectorAll('[data-track]');
|
|
trackedElements.forEach(function(element) {
|
|
element.addEventListener('click', function(e) {
|
|
const eventName = element.getAttribute('data-track') || 'tracked_element';
|
|
const details = getElementDetails(element);
|
|
tE(eventName, { element: 'data-track', ...details });
|
|
});
|
|
});
|
|
});
|
|
</script>
|
|
<?php
|
|
}
|
|
|
|
/**
|
|
* Shortcode for tracking elements
|
|
*/
|
|
public function tracking_shortcode($atts, $content = null) {
|
|
$atts = shortcode_atts(array(
|
|
'event' => 'tracked_element',
|
|
'class' => '',
|
|
'style' => '',
|
|
), $atts, 'track_element');
|
|
|
|
// Sanitize attributes
|
|
$event = esc_attr($atts['event']);
|
|
$class = esc_attr($atts['class']);
|
|
$style = esc_attr($atts['style']);
|
|
|
|
// Return the div with content and onclick attribute
|
|
return sprintf(
|
|
'<div class="tracking-wrapper %s" style="%s" onclick="tE(\'%s\')">%s</div>',
|
|
$class,
|
|
$style,
|
|
$event,
|
|
do_shortcode($content)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Register Gutenberg tracking block
|
|
*/
|
|
public function register_tracking_block() {
|
|
// Only register block if Gutenberg is available
|
|
if (!function_exists('register_block_type')) {
|
|
return;
|
|
}
|
|
|
|
// Register block script
|
|
wp_register_script(
|
|
'tracking-block-editor',
|
|
plugins_url('block.js', __FILE__),
|
|
array(
|
|
'wp-blocks',
|
|
'wp-element',
|
|
'wp-block-editor',
|
|
'wp-components',
|
|
'wp-i18n'
|
|
),
|
|
filemtime(plugin_dir_path(__FILE__) . 'block.js')
|
|
);
|
|
|
|
// Register block styles
|
|
wp_register_style(
|
|
'tracking-block-editor-style',
|
|
plugins_url('block.css', __FILE__),
|
|
array(),
|
|
filemtime(plugin_dir_path(__FILE__) . 'tracking-block.css')
|
|
);
|
|
|
|
// Register the block
|
|
register_block_type('simplified-tracking/track-element', array(
|
|
'editor_script' => 'tracking-block-editor',
|
|
'editor_style' => 'tracking-block-editor-style',
|
|
'attributes' => array(
|
|
'eventName' => array(
|
|
'type' => 'string',
|
|
'default' => 'tracked_element',
|
|
),
|
|
),
|
|
));
|
|
|
|
// Add inline script to ensure tE function is available in editor
|
|
wp_add_inline_script('tracking-block-editor', "
|
|
// Mock tE function for the editor if it doesn't exist
|
|
if (typeof window.tE === 'undefined') {
|
|
window.tE = function(eventName) {
|
|
console.log('Tracking event: ' + eventName);
|
|
};
|
|
}
|
|
");
|
|
}
|
|
|
|
/**
|
|
* Register tracking endpoint
|
|
*/
|
|
public function register_tracking_endpoint() {
|
|
add_rewrite_rule('^track/?$', 'index.php?tracking_endpoint=1', 'top');
|
|
add_rewrite_tag('%tracking_endpoint%', '1');
|
|
add_action('parse_request', array($this, 'handle_tracking_request'));
|
|
|
|
// Flush rewrite rules only on plugin activation
|
|
if (get_option('simple_tracking_flush_rules', false)) {
|
|
flush_rewrite_rules();
|
|
update_option('simple_tracking_flush_rules', false);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handle tracking request
|
|
*/
|
|
public function handle_tracking_request($wp) {
|
|
if (isset($wp->query_vars['tracking_endpoint'])) {
|
|
$this->forward_to_tracker();
|
|
exit;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Forward the request to the tracking server
|
|
*/
|
|
public function forward_to_tracker() {
|
|
// Get tracking server URL from settings
|
|
$tracking_server_url = get_option('simple_tracking_server_url', $this->tracking_server_url);
|
|
$forward_url = 'https://' . $tracking_server_url . '/spur';
|
|
|
|
// Create a new cURL resource
|
|
$ch = curl_init();
|
|
|
|
// Set URL and other appropriate options
|
|
curl_setopt($ch, CURLOPT_URL, $forward_url);
|
|
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
|
|
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
|
|
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $_SERVER['REQUEST_METHOD']);
|
|
|
|
// Get query parameters and add IP
|
|
$query = $_GET;
|
|
$query['ip'] = $this->get_real_ip();
|
|
|
|
// Build query string
|
|
$query_string = http_build_query($query);
|
|
curl_setopt($ch, CURLOPT_URL, $forward_url . '?' . $query_string);
|
|
|
|
// Prepare headers
|
|
$headers = array();
|
|
$all_headers = function_exists('getallheaders') ? getallheaders() : $this->get_all_headers();
|
|
|
|
// Forward all headers, checking for the final destination
|
|
foreach ($all_headers as $name => $value) {
|
|
if ($name == 'X-Final-Destination' && !empty($value)) {
|
|
// If a custom destination is provided in the header, use it
|
|
$forward_url = 'https://' . $value . '/spur';
|
|
curl_setopt($ch, CURLOPT_URL, $forward_url . '?' . $query_string);
|
|
}
|
|
$headers[] = "$name: $value";
|
|
}
|
|
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
|
|
|
|
// Execute request
|
|
$response = curl_exec($ch);
|
|
$http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
|
|
|
|
if (curl_errno($ch)) {
|
|
$http_code = 500;
|
|
}
|
|
|
|
// Close cURL resource
|
|
curl_close($ch);
|
|
|
|
// Send response
|
|
http_response_code($http_code);
|
|
header('Content-Type: application/json');
|
|
echo '{}';
|
|
exit;
|
|
}
|
|
|
|
/**
|
|
* Fallback implementation of getallheaders() for servers that don't have it
|
|
*/
|
|
private function get_all_headers() {
|
|
$headers = [];
|
|
foreach ($_SERVER as $name => $value) {
|
|
if (substr($name, 0, 5) == 'HTTP_') {
|
|
$headers[str_replace(' ', '-', ucwords(strtolower(str_replace('_', ' ', substr($name, 5)))))] = $value;
|
|
}
|
|
}
|
|
return $headers;
|
|
}
|
|
|
|
/**
|
|
* Get the real IP address
|
|
*/
|
|
private function get_real_ip() {
|
|
if (!empty($_SERVER['HTTP_CLIENT_IP'])) {
|
|
$ip = $_SERVER['HTTP_CLIENT_IP'];
|
|
} elseif (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {
|
|
$ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
|
|
} else {
|
|
$ip = $_SERVER['REMOTE_ADDR'];
|
|
}
|
|
return $ip;
|
|
}
|
|
|
|
/**
|
|
* Add settings page
|
|
*/
|
|
public function add_settings_page() {
|
|
add_options_page(
|
|
'Tracking Settings',
|
|
'Tracking Settings',
|
|
'manage_options',
|
|
'simple-tracking-settings',
|
|
array($this, 'render_settings_page')
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Register settings
|
|
*/
|
|
public function register_settings() {
|
|
register_setting('simple_tracking_settings', 'simple_tracking_server_url');
|
|
register_setting('simple_tracking_settings', 'simple_tracking_track_classes');
|
|
|
|
add_settings_section(
|
|
'simple_tracking_section',
|
|
'Tracking Settings',
|
|
array($this, 'settings_section_callback'),
|
|
'simple-tracking-settings'
|
|
);
|
|
|
|
add_settings_field(
|
|
'simple_tracking_server_url',
|
|
'Tracking Server URL',
|
|
array($this, 'server_url_callback'),
|
|
'simple-tracking-settings',
|
|
'simple_tracking_section'
|
|
);
|
|
|
|
add_settings_section(
|
|
'simple_tracking_auto_section',
|
|
'Element Tracking Settings',
|
|
array($this, 'auto_settings_section_callback'),
|
|
'simple-tracking-settings'
|
|
);
|
|
|
|
add_settings_field(
|
|
'simple_tracking_track_classes',
|
|
'Track Elements with Classes',
|
|
array($this, 'track_classes_callback'),
|
|
'simple-tracking-settings',
|
|
'simple_tracking_auto_section'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Settings section callback
|
|
*/
|
|
public function settings_section_callback() {
|
|
echo '<p>Configure your tracking server settings.</p>';
|
|
}
|
|
|
|
/**
|
|
* Auto tracking settings section callback
|
|
*/
|
|
public function auto_settings_section_callback() {
|
|
echo '<p>Configure which elements to track based on CSS classes.</p>';
|
|
}
|
|
|
|
/**
|
|
* Server URL field callback
|
|
*/
|
|
public function server_url_callback() {
|
|
$value = get_option('simple_tracking_server_url', $this->tracking_server_url);
|
|
echo '<input type="text" id="simple_tracking_server_url" name="simple_tracking_server_url" value="' . esc_attr($value) . '" class="regular-text">';
|
|
echo '<p class="description">Enter the tracking server URL without https:// (e.g., tracking1.karlbreuer.com)</p>';
|
|
echo '<p class="description">You will find this in your domain screen in the Palantics app</p>';
|
|
}
|
|
|
|
/**
|
|
* Track classes callback
|
|
*/
|
|
public function track_classes_callback() {
|
|
$value = get_option('simple_tracking_track_classes', '');
|
|
echo '<input type="text" id="simple_tracking_track_classes" name="simple_tracking_track_classes" value="' . esc_attr($value) . '" class="regular-text">';
|
|
echo '<p class="description">Enter comma-separated class names to automatically track clicks on elements with these classes (e.g., cta-button, featured-product)</p>';
|
|
}
|
|
|
|
/**
|
|
* Render settings page
|
|
*/
|
|
public function render_settings_page() {
|
|
?>
|
|
<div class="wrap">
|
|
<h1><?php echo esc_html(get_admin_page_title()); ?></h1>
|
|
<form method="post" action="options.php">
|
|
<?php
|
|
settings_fields('simple_tracking_settings');
|
|
do_settings_sections('simple-tracking-settings');
|
|
submit_button();
|
|
?>
|
|
</form>
|
|
|
|
<div style="background-color: #fff; padding: 20px; margin-top: 20px; border: 1px solid #ccc; border-radius: 4px;">
|
|
<h2>Manual Tracking Methods</h2>
|
|
|
|
<div style="margin-bottom: 20px;">
|
|
<h3>Method 1: Using Data Attributes</h3>
|
|
<p>Add the <code>data-track</code> attribute to any HTML element to track clicks:</p>
|
|
<pre style="background-color: #f5f5f5; padding: 10px; border-radius: 4px;"><button data-track="signup_button_click">Sign Up</button></pre>
|
|
</div>
|
|
|
|
<div style="margin-bottom: 20px;">
|
|
<h3>Method 2: Using Shortcode</h3>
|
|
<p>Wrap any content with the shortcode to track clicks:</p>
|
|
<pre style="background-color: #f5f5f5; padding: 10px; border-radius: 4px;">[track_element event="download_click" class="your-class" style="your-style"]
|
|
Your content here (can include other shortcodes)
|
|
[/track_element]</pre>
|
|
</div>
|
|
|
|
<div>
|
|
<h3>Method 3: Using Direct JavaScript</h3>
|
|
<p>You can also manually add <code>onclick="tE('your_event_name')"</code> to any HTML element.</p>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
<?php
|
|
}
|
|
|
|
/**
|
|
* Activate plugin
|
|
*/
|
|
public static function activate() {
|
|
// Set flag to flush rewrite rules on next load
|
|
update_option('simple_tracking_flush_rules', true);
|
|
}
|
|
}
|
|
|
|
// Initialize the plugin
|
|
function simplified_tracking_init() {
|
|
Simplified_Tracking_Plugin::get_instance();
|
|
}
|
|
add_action('plugins_loaded', 'simplified_tracking_init');
|
|
|
|
// Register activation hook
|
|
register_activation_hook(__FILE__, array('Simplified_Tracking_Plugin', 'activate'));
|