Skip to main content

Tag Management

Before being able to configure rules for a tag, it must exist in your configuration.

  1. Go to Tags > Tag Management.

  2. Import a tag:

    • Click on Import a tag.
    • Netvigie Tracking has a library of over 3000 pre-configured tags (Google Analytics, Criteo, Facebook, etc.).
    • Search and select the desired tag. Its pattern (the regular expression that identifies the tag URL) will be automatically filled.

  3. Add a tag manually:

    • If your tag is not in the library, click on Add a tag.
    • Fill in its name, its type, and especially its main pattern.
    • You can also define the parameters expected in the tag URL and their own format (via a regex).

Page included in tag management​

With content otherwise it's not fun

Tagging Plan Configuration

Advanced Tag Parameter Options​

When configuring a tag in Tags > Tag Management, beyond the simple pattern, you have advanced options that give you granular control over how Netvigie Tracking interprets and validates this tag.

Tag Uniqueness​

By default, a tag can fire multiple times on the same page without it being considered an error. However, for certain tags (like a pageview tag), multiple firing is often a sign of an issue.

  • How to activate it? By editing a tag, check the option "Tag Uniqueness".
  • Behavior: Once this option is activated, if more rules are validated for this tag than there are configured rules, a duplication error will be raised.
    • Example: You have a single rule for the "GUA Pageview" tag on the "Product Page" context. If the tag is detected twice on a page of this context, the second firing will be flagged as a duplication and will negatively impact your Tag Score.

Tag Post-processing​

For certain specific tag types (like Eulerian, Amplitude, Snowplow), Netvigie Tracking can apply automatic post-processing to manage their particular data structures. This option is to be used if you work with one of these solutions.

Advanced Parameter Processing (Options)​

This is the most powerful feature. It is located at the configuration level of each parameter of a tag. Its goal is to decode, parse and transform the value of a parameter before verifying it. It is essential when tags transmit complex, structured or encoded data in a single parameter.

  • Why use it? Imagine a tag that sends a string like this: data=cHJvZHVjdElEPUFETUlO... (Base64 encoded data) or event_data=product_view,12345,T-shirt (structured data with commas). To verify that the product ID is indeed 12345, you must first parse the string.
  • How does it work? In the "Options" field of a parameter, you can enter a chain of commands, separated by commas. These commands are executed in sequence, from left to right.
  • List of Available Options:
    • b64: Decodes the value from Base64 format.
    • json: Parses the string as a JSON object.
    • p: Parses the string using the comma (,) as a separator. Returns an array.
    • pX: Parses the string using the character X as a separator. E.g.: p| to parse with a pipe |.
    • PX: Acts like pX, but the options that follow in the chain apply to the entire resulting array, and not to each element individually. This is a subtle but important distinction for chained processing.
    • eX: Extracts the element at index X of an array, or the value of the property named X of an object.
    • = : Transforms a key=value string into a { key: "value" } object. If applied to an array of such strings, it returns an object.
    • [index:options]: An advanced syntax that allows applying a new chain of options specifically to the element located at a given index of the array resulting from a previous parsing operation.
  • Practical Examples:

    • Example 1 (Simple - Amplitude Case): A parameter contains Base64 encoded data, which, once decoded, is a JSON object. You want to verify the first element.

      • Option to use: b64,json,e0
      • Breakdown:
        1. b64: The parameter value is decoded from Base64.
        2. json: The result (a text string) is parsed into a JavaScript object.
        3. e0: The first element (at index 0) of this object/array is extracted. It is this final value that will be used for verification.

    • Example 2 (Complex - Structured String): A parameter contains the value prod|100|home|particuliers||client=oui|user=123. You wish to verify multiple parts of this complex string.

      • Option to use: p|,[5:P=]
      • Breakdown:
        1. p|: First, we parse the entire string using the pipe | as a separator. We obtain an array: ["prod", "100", "home", "particuliers", "", "client=oui", "user=123"].
        2. ,: The comma separates the first command from the next.
        3. [5:P=]: This is where the magic happens.
          • [5: ... ]: We specifically target the element at index 5 of the array, which is the string "client=oui".
          • :P=: We apply a new series of options to this element. P indicates that the option = will apply to the result of the parsing. The option = transforms the string "customer=yes" into an object { customer: "yes" }.

      This advanced syntax allows you to extract and validate sub-parts of highly structured data within a single parameter, offering almost unlimited testing flexibility.