English

The domain name 'io-av7.pages.dev' uses the developer-focused generic top-level domain (.dev); it also runs on subdomain 'io-av7'. The second-level label 'pages' is 5 characters long holding two vowels versus 3 consonants. It segments into one word: pages. No strong language cues emerged from the frequency lists.

html/7d/a8/7da8a5b0-f773-4d65-a10e-8d27c2831fc6.html.gz

88aa4012fedc92b8e553f215e04a13a3d9fd2aed24af73352aa12aaabc5b2106

82f64f62bb03c1bc1824b0f9c9e05f70dba33e146818e63cdf5c306c8cf3dedd

48444a82d4edcb5bec0f1965faacdde18d9c17db3063d042abada2f705c9f54a

bb2a32f244a017faac2787d1efe89ac29e1ea572c0b9872294443894f4dfeacb

595989f46e61382c015a26f78b1e8afdbad91c5290a1f3a614746af5c218713f

8036be01f5a27db9570b2270209c250297565e8bf538420aff111a40120a6f4a

ae94f2c9e9dbd7c71d7f53de026699c8e1e06f4026cd87ac842884bcbe8267fd

io.trudov.com Online tools by Aleksei Trudov

viewport

Standardize and clean GA4 source/medium data using custom mapping rules. Ideal for making sense from messy CSV exports.

description

Abuse Team

CloudFlare, Inc.

pages.dev

Abuse Account

Fastly RIR Administrator

Fastly Network Operations

Fastly, Inc.

SKYCA-3


import csv
import json
import io
import re

def normalize_source(source):
    if not source:
        return ""
    s = source.lower().strip()

    # 1. Connector-Based Logic
    TLD_CONNECTORS = ["com", "co", "net", "org", "gov", "edu", "ac", "biz", "info"]
    PROTECTED_TLDS = {"com", "org", "net", "edu", "gov", "mil", "ru", "uk", "de", "jp", "fr", "au", "us", "ca", "ch", "it", "nl", "se", "no", "es", "br", "cn", "in", "io", "co", "me", "tv", "info", "biz"}

    # 2. Refined Extraction
    segments = s.split('.')
    brand = s # Default to full domain

    if len(segments) >= 3 and segments[-2] in TLD_CONNECTORS:
        brand = segments[-3]
    elif len(segments) >= 2:
        brand = segments[-2]
    else:
        brand = segments[0]

    # 3. Safety Check
    if brand in PROTECTED_TLDS:
        return s

    return brand

def process_ga4_data(csv_content, mapping_json_str):
    try:
        # Load mapping
        try:
            mapping = json.loads(mapping_json_str)
        except json.JSONDecodeError as e:
            return json.dumps({"error": f"Invalid JSON in mapping config: {str(e)}"})

        # Pre-process content to remove comments/empty lines for Sniffer and Reader
        f = io.StringIO(csv_content)
        raw_lines = [line.strip() for line in f if line.strip() and not line.strip().startswith('#')]

        if not raw_lines:
             return json.dumps({"error": "No valid data found in CSV (file is empty or only comments)."})

        # Robust Header Detection
        header_index = -1
        delimiter = ',' # Default
        detected_header_line = ""

        # Find header line containing "source / medium"
        for i, line in enumerate(raw_lines):
            # Check likely delimiters
            for d in [',', ';', '\t']:
                if "source / medium" in line.lower():
                     header_index = i
                     delimiter = d
                     detected_header_line = line
                     break
            if header_index != -1:
                break

        if header_index == -1:
            # Fallback: Try Sniffer on first few lines if we couldn't find explicit "source / medium"
            # But likely this file is not what we expect. Let's assume index 0 if detection fails but try standard sniff.
            header_index = 0
            sample_data = '\n'.join(raw_lines[:10])
            try:
                dialect = csv.Sniffer().sniff(sample_data, delimiters=',;\t')
                delimiter = dialect.delimiter
            except csv.Error:
                pass

        # Slicing from header
        data_lines = raw_lines[header_index:]

        reader = csv.DictReader(data_lines, delimiter=delimiter)

        # Identify Metric Columns
        fieldnames = reader.fieldnames
        if not fieldnames:
             return json.dumps({"error": "CSV has no headers."})

        # Find the actual key column name (e.g. "Session source / medium")
        source_col_name = None
        for col in fieldnames:
            if "source / medium" in col.lower():
                source_col_name = col
                break

        if not source_col_name:
             # Fallback if we missed it somehow but header detection worked
             return json.dumps({"error": "Column containing 'Source / medium' not found."})

        # Read all rows
        rows = list(reader)
        if not rows:
             return json.dumps({"error": "CSV contains no data rows."})

        # Discovery Logic
        metric_cols = []
        # Exclude known non-metrics
        excluded_cols = {source_col_name.lower().strip(), "source", "medium"}

        for col in fieldnames:
            if col.lower().strip() in excluded_cols:
                continue

            # Check first 10 rows (or fewer)
            check_rows = rows[:10]
            non_empty_count = 0
            float_count = 0

            for row in check_rows:
                val = row.get(col, "").strip()
                if not val:
                    continue
                if val.lower() == "grand total":
                    continue

                non_empty_count += 1
                try:
                    float(val.replace(',', '.'))
                    float_count += 1
                except ValueError:
                    pass

            if non_empty_count > 0:
                ratio = float_count / non_empty_count
                if ratio > 0.8:
                    metric_cols.append(col)

        if not metric_cols:
             return json.dumps({"error": "No numeric metric columns found."})

        # Initialize Aggregation Structure
        results_by_metric = {}
        for m in metric_cols:
            results_by_metric[m] = {
                "totals": {cat: 0.0 for cat in mapping.keys()},
                "grand_total": 0.0,
                "_aggregated": {}
            }
            results_by_metric[m]["totals"]["Other"] = 0.0

        # Pass 2: Aggregate
        for row in rows:
            source_medium = row.get(source_col_name, "")
            if not source_medium or source_medium.lower() == "grand total":
                 continue

            parts = source_medium.split(' / ')
            if len(parts) >= 2:
                source_raw = parts[0]
                medium_raw = parts[1]
            else:
                source_raw = source_medium
                medium_raw = "(not set)"

            source_norm = normalize_source(source_raw)
            medium_norm = medium_raw.lower().strip()

            # Determine Category
            category = "Other"
            matched = False

            # Priority 1: Source Match
            for cat, rules in mapping.items():
                if "sources" in rules:
                    for rule_source in rules["sources"]:
                        if re.search(r'(^|\b)' + re.escape(rule_source) + r'(\b|$)', source_norm):
                             category = cat
                             matched = True
                             break
                if matched: break

            if not matched:
                for cat, rules in mapping.items():
                    if "mediums" in rules:
                         if medium_norm in rules["mediums"]:
                             category = cat
                             matched = True
                             break

            # Add values for each metric
            for m in metric_cols:
                try:
                    val_str = row.get(m, "0")
                    value = float(val_str.replace(',', '.'))
                except ValueError:
                    value = 0.0

                # Update Totals
                if category not in results_by_metric[m]["totals"]:
                    results_by_metric[m]["totals"][category] = 0.0
                results_by_metric[m]["totals"][category] += value
                results_by_metric[m]["grand_total"] += value

                # Update Row Aggregation
                agg_key = (category, source_norm)
                agg_storage = results_by_metric[m]["_aggregated"]

                if agg_key not in agg_storage:
                    agg_storage[agg_key] = {
                        "value": 0.0,
                        "details": {}
                    }

                agg_storage[agg_key]["value"] += value

                if source_medium not in agg_storage[agg_key]["details"]:
                    agg_storage[agg_key]["details"][source_medium] = 0.0
                agg_storage[agg_key]["details"][source_medium] += value

        # Final Formatting
        final_output = {
            "metrics": metric_cols,
            "results": {}
        }

        for m in metric_cols:
            rows_list = []
            agg_storage = results_by_metric[m]["_aggregated"]

            for (cat, merged_source), data in agg_storage.items():
                sorted_details = sorted(data["details"].items(), key=lambda x: x[1], reverse=True)

                csv_items = [f"{src} ({val:.1f})" for src, val in sorted_details]
                tooltip_items = [f"{src} ({val:.1f})" for src, val in sorted_details]

                csv_str = "; ".join(csv_items)
                tooltip_str = "\n".join(tooltip_items)

                rows_list.append({
                    "category": cat,
                    "merged_source": merged_source,
                    "original_sources_csv": csv_str,
                    "original_sources_tooltip": tooltip_str,
                    "value": data["value"]
                })

            final_output["results"][m] = {
                "totals": results_by_metric[m]["totals"],
                "rows": sorted(rows_list, key=lambda x: x['value'], reverse=True),
                "grand_total": results_by_metric[m]["grand_total"]
            }

        return json.dumps(final_output)

    except Exception as e:
        return json.dumps({"error": f"Processing error: {str(e)}"})


HTTP/3

Cloudflare Bot Management

Cloudflare

jsDelivr

GA4 Attribution Cleaner - Standardize Source/Medium Data in CSV exports from Google Analytics 4 ~ Free online tools by Aleksei Trudov

✅ Low Risk - https://io-av7.pages.dev/tools/ga4-attribution-cleaner/

Requests	IP Address	Location	AS Autonomous System
5	188.114.96.3	United States	AS13335Cloudflare, Inc.
5	104.16.174.226	United States	AS13335Cloudflare, Inc.
10	2	-	-

Security Scan Report: io-av7.pages.dev

Summary

AI Security Verdict

Low Risk

Risk Factors

Safety Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Detected Technologies4

Content Similarity HashesFor malware variant detection

TLSH (Trend Micro Locality Sensitive Hash)

ssdeep (Context Triggered Piecewise Hashing)

sdhash (Similarity Digest Hashing)

Image Hashes

Perceptual Hashes

Other Hashes

Scan History