Classes

Methods

constructor

For a complete configuration of the Mapp Intelligence Hybrid please check Configuration.

The hybrid writes the requests into log files that you send with the Cron Job: the constructor sets the consumer type of the configuration that you pass in to FILE, unless it is CUSTOM. This changes your configuration object: maxBatchSize becomes 1, and filePath and filePrefix get their defaults if they are empty.

/**
 * @param config Mapp Intelligence configuration
 */
MappIntelligenceHybrid mappIntelligenceHybrid = new MappIntelligenceHybrid(MappIntelligenceConfig config);

track

Reads all query parameters from the current request URL (see setRequestURL in Configuration) and saves the request in the internal queues, which are sent at defined intervals, via flush call or when the instance is closed. The return value is the request queue ID, or -1 if nothing was added.

• Only pixel requests are accepted: the query string has to contain the pixel parameter p with a value and may be at most 64 KB (see isValidPixelRequest). Any other request is ignored (logged at level WARN) instead of being written into the log files.

• The parameters that only the server may set are removed from the client request first: X-WT-IP, X-WT-UA and X-WT-SEC-CH-UA*, so a client cannot pretend to be another user. The library then adds user agent, IP address and client hints from the configuration, if they are set there.

• track(String rURL) with a malformed URL or null does not track anything and returns -1. The previous request URL is not tracked again.

• Unlike MappIntelligenceTracking, the hybrid does not add the everID (eid), because the pixel requests carry their own. It also does not check the track ID or track domain and does not apply the include/exclude filters.

mappIntelligenceHybrid.track();

/**
 * @param rURL request url with query parameters
 */
mappIntelligenceHybrid.track(String rURL);

isValidPixelRequest

Checks whether a query string is accepted by track: it must not be null, must contain the pixel parameter p with a value (p=...) and may be at most 64 KB (65,536 bytes, measured in UTF-8).

/**
 * @param queryString Query string of the pixel request
 *
 * @return true if the query string contains the pixel parameter "p" and is not too long
 */
boolean valid = MappIntelligenceHybrid.isValidPixelRequest(String queryString);

flush

Here you can explicitly tell to send the data to the Mapp tracking servers.

/**
 *
 */
mappIntelligenceHybrid.flush();

setOnFlushComplete

Here you can define a callback method that is automatically called after each flush. The first argument is the status of the request dispatch. The second argument specifies which queue was involved.

/**
 * @param callback Callback for complete flushing
 */
mappIntelligenceHybrid.setOnFlushComplete(BiConsumer<Boolean, Integer> callback);

close

Same as MappIntelligenceTracking.close(): sends the remaining requests, waits up to 30 seconds (one deadline for all queues) for them to be handed to the consumer, releases thread pools and file handles, and is idempotent. Use one instance per request with try-with-resources (see the example below).

/**
 *
 */
mappIntelligenceHybrid.close();

getUserIdCookie

Returns the same cookies as MappIntelligenceTracking.getUserIdCookie() (see the MappIntelligenceTracking tab), so a user without everID gets one. The generated everID is not added to the requests of the hybrid, because the requests forwarded from the pixel carry their own eid.

/**
 * @param pixelVersion Version ot the current pixel (v4, v5, smart)
 * @param context Cookie context (CLIENT_SIDE_COOKIE = "1", SERVER_SIDE_COOKIE = "3")
 *
 * @return MappIntelligenceCookie
 */
MappIntelligenceCookie mappCookie = mappIntelligenceHybrid.getUserIdCookie(String pixelVersion, String context);

Note

getTransmittedCampaignsCookie() is also available on MappIntelligenceHybrid, but it always returns null there: the hybrid forwards the pixel requests unchanged and does not evaluate campaigns.

getResponseAsString

As response, the method returns a 1x1px transparent gif, which you then returned to the client.

/**
 * @return Returns a 1x1px transparent gif as string.
 */
String imageString = mappIntelligenceHybrid.getResponseAsString();

Note

The string is created from the GIF bytes with the platform default charset, so it does not reliably contain the original bytes. To send the image to the client, use getResponseAsBytes.

getResponseAsBytes

As response, the method returns a 1x1px transparent gif, which you then returned to the client.

/**
 * @return Returns a 1x1px transparent gif as byte array.
 */
byte[] imageBytes = mappIntelligenceHybrid.getResponseAsBytes();

Example

package demo.servlets;
import com.mapp.intelligence.tracking.MappIntelligence;
import com.mapp.intelligence.tracking.MappIntelligenceCookie;
import com.mapp.intelligence.tracking.config.MappIntelligenceConfig;
import com.mapp.intelligence.tracking.core.MappIntelligenceHybrid;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.OutputStream;

@WebServlet("/pix/*")
public class TrackingServlet extends HttpServlet {
    public TrackingServlet() {
        super();
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // set tracking configuration
        MappIntelligenceConfig mappConfig = new MappIntelligenceConfig()
            .setTrackId("111111111111111")
            .setTrackDomain("analytics01.wt-eu02.net")
            .setReferrerURL(request.getHeader("Referer"))
            // with the query string: the hybrid forwards the query parameters of the pixel request
            .setRequestURL(request.getRequestURL() + (request.getQueryString() != null ? "?" + request.getQueryString() : ""))
            .setRemoteAddress(request.getRemoteAddr())
            .setUserAgent(request.getHeader("User-Agent"));

        // read out all client cookies and add them to the configuration
        Cookie[] cookies = request.getCookies();
        if (cookies != null) {
            for (Cookie cookie : cookies) {
                mappConfig.addCookie(cookie.getName(), cookie.getValue());
            }
        }

        // the instance carries the data of this request, so it is created and closed per request;
        // close() sends the remaining requests
        try (MappIntelligenceHybrid mappHybrid = new MappIntelligenceHybrid(mappConfig)) {
            // writes the incoming request to the Mapp Intelligence request queue
            mappHybrid.track();

            byte[] imgBytes = mappHybrid.getResponseAsBytes();

            // set content-type and length
            response.setContentType("image/gif");
            response.setContentLength(imgBytes.length);

            // read out the existing Mapp Intelligence user cookie
            MappIntelligenceCookie mappUserCookie = mappHybrid.getUserIdCookie(MappIntelligence.SMART, MappIntelligence.CLIENT_SIDE_COOKIE);
            if (mappUserCookie != null) {
                // create a cookie
                Cookie mappUserCookieResponse = new Cookie(mappUserCookie.getName(), mappUserCookie.getValue());
                mappUserCookieResponse.setHttpOnly(mappUserCookie.isHttpOnly());
                mappUserCookieResponse.setSecure(mappUserCookie.isSecure());
                // the v4 and smart pixel cookies have no domain (empty string)
                if (!mappUserCookie.getDomain().isEmpty()) {
                    mappUserCookieResponse.setDomain(mappUserCookie.getDomain());
                }
                mappUserCookieResponse.setPath(mappUserCookie.getPath());
                mappUserCookieResponse.setMaxAge(mappUserCookie.getMaxAge());
                // add the cookie to the response
                response.addCookie(mappUserCookieResponse);
            }

            // send a 1x1 pixel transparent gif back to the client, unchanged
            OutputStream out = response.getOutputStream();
            out.write(imgBytes);
        }
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
    }
}