#
#  Copyright 2017 Quest Software Inc.
#
# ALL RIGHTS RESERVED.
#

##############################################################################
# Recording configuration
##############################################################################

# Rules for separating requests. Request separation happens first. The keys
# may be strings or regular expressions, the values are lists of URL parameter
# names (strings). Do not include the HTTP method in this section.
#
# Example:
#    SeparationRules = {
#        /\/path\/servlet$/ : ("parameter1", "parameter2"),
#        "/account/balance.do" : ("type"),
#        "/main.action" : ("parameter1"),
#    };
#
SeparationRules = {
};

# The maximum size of request parameters that will be read for the purpose of
# separating requests. The maximum separation value size is 999.
MaxSeparationValueSize = 32;

# Rules for URL Transformation. If Separation Rules have been defined for
# the URL that is to be transformed, then the transformation will be performed
# on the separated URL, which will include the path and separation parameters.
# There may be more than one transformation defined. Each transformation may
# contain more than one replacement definition. The configuration syntax is as
# follows:
#
# URLTransformationRules = {
#	/<url-regex>/ : {
#		/<text-in-url-regex>/ : <replacement-literal>,
#	},
#	/<url-regex>/ : {
#		/<text-in-url-regex-1>/ : <replacement-literal-1>,
#		/<text-in-url-regex-2>/ : <replacement-literal-2>,
#	},
# };
#
# Where:
#
# <url-regex> is a regular expression used to match the URLs that need to be
#   transformed. The '/' and '?' characters must be escaped with a '\'
#   character.
#
# <text-in-url-regex> is a regular expression used to match the text that
# 	needs to be replaced in the url. The '/' and '?' characters must be escaped
# 	with a '\' character.
#
# <replacement-literal> is a string literal of the replacement text; this can
# 	be an empty string. It can also contain markers used to substitute
#	subexpressions from the <text-in-url-regex>, which are sequences of characters
#	surrounded by parentheses. Valid markers for substitution are:
#		-  "&" or "\0" is replaced with a copy of the entire matched region.
#		-  "\n", where n is a digit from 1 to 9, is replaced with a copy of the
#			nth subexpression.
#		-  "\&" or "\\" are replaced with just "&" or "\" to escape their
#			special meaning.
#		-  any other character is passed through.
#
# Order is important. The transformation will be performed using the list of
# replacements defined for the first matching <url-regex> that is found. The
# replacements will be performed in the order in which they are defined. Each
# replacement will be performed on the URL resulting from the previous
# replacement.
URLTransformationRules = {
/\/docs\/.*/ : {
},
/\/product\/.*/ :{
/\/product\/checkout\/.*/: "/product/checkout/",
/\/product\/summary\/.*/: "/product/summary/",
},
 /\/calendar\/control\/timeframe=.*/ : {
    /&id=[0-9]+/: "",
},
/\?/ : {
/(.*)/ : "\\1",
},
/\.(gif|GIF|Gif|jpg|jpeg|JPG|JPEG|Jpg|Jpeg|png|PNG|Png|css|CSS|Css|js|JS|Js|ico|ICO|Ico)$/ : {
/(.*)/ : "\\1",
},
/^\/[^\/]+\/[^\/]+\/[^\/]+\/[^\/]+/ : {
/^\/([^\/]+)\/([^\/]+)\/([^\/]+)\/.*/ : "/\\1/\\2/\\3/*",
},
/^\/[^\/]+\/[^\/]+\/[^\/]+$/ : {
/^\/([^\/]+)\/([^\/]+)\/.*/ : "/\\1/\\2/*",
},
/^\/[^\/]+\/[^\/]+$/ : {
/^\/([^\/]+)\/.*/ : "/\\1/*",
},
/^\/[^\/]+$/ : {
/^\/[^\/]*$/ : "/*",
}
};

# Rules for filtering requests. Filtering occurs after separation and so can
# include separation parameters. Filtering also occurs after URL transformation
# and so must be defined in terms of transformed URLs, rather than their
# original form. The keys may be strings or regular expressions, the values are
# booleans indicating whether the request may be eligible for sampling. HTTP
# method can be included in this section.
#
# If a request is filtered out, then it can not be traced.
#
# By default, the following request types are included:
#    1. HTTP requests, using the (GET|POST|...) filter.
#    2. RMI and JMS requests, using the ":" filter.
#
FilteringRules = {
    /\.(gif|GIF|Gif)$/ : false,
    /\.(jpg|jpeg|JPG|JPEG|Jpg|Jpeg)$/ : false,
    /\.(png|PNG|Png)$/ : false,
    /\.(css|CSS|Css)$/ : false,
    /\.(js|JS|Js)$/ : false,
    /\.(ico|ICO|Ico)$/ : false,
    /^(GET|POST|DELETE|HEAD|OPTIONS|PUT|TRACE)/ : true,
	/::/ : false,
    /:/ : true,
};

# A boolean indicating whether requests that do not match any of the
# FilteringRules may be eligible for sampling.
FilteringDefault = false;

# Rules for the collection of details on sampled requests. The keys can be
# strings or regular expressions to match a URL, and the values specify which
# request detail information to collect. Request detail collection occurs
# after URL transformation, separation, and filtering rules are applied.
#
# The values used to collect details are the following, and may appear in any
# order and combination:
#
#   TierBreakdown
#   ServerBreakdown
#   ApplicationBreakdown
#   ComponentTechnologyBreakdown
#   IndividualRequestBreakdowns
#
# For example, to collect component technology breakdown detail for all
# requests that perform a "transfer", all breakdown details for "login.jsp",
# and server breakdown details for "index.do" for aggregated and individual
# requests, the rules would be:
#
#    RequestDetailRules = {
#       /.*\/transfer\-.*\.jsp$/ : ("ComponentTechnologyBreakdown"),
#       /.*\/login\.jsp$/ : ("TierBreakdown", "ServerBreakdown", "ApplicationBreakdown", "ComponentTechnologyBreakdown"),
#       "/index.do" : ("ServerBreakdown", "IndividualRequestBreakdowns"),
#    };
#
# By default, no breakdown details are collected.
#
RequestDetailRules = {
};

# By default, individual request breakdowns are enabled.
#
# For example, to collect TierBreakdown information for all requests that do
# not match the rules above:
#
#    RequestDetailDefault = ("TierBreakdown");
#
# NOTE: It is not recommended to simply set the default to collect all
#    breakdown details. Instead, creating a appropriate request detail rules
#    to selectively sample and/or exclude requests should be considered before
#    modifying this setting.
RequestDetailDefault = (
	"IndividualRequestBreakdowns",
);

# The unit size in seconds. Only used in conjunction with the max samples per
# time slice setting in the periodic metric collector configuration files.
TimeSliceSize = 300;

# The interval at which periodic metric collectors will discover changes to the
# appserver structure such as new applications, in seconds.
CollectorDiscoveryInterval = 300;

# The incomplete request timeout, in seconds.
IncompleteRequestTimeout = 120;

# The maximum amount of time that the Agent will track a live object, in
# seconds.  Increasing this value gives the garbage collector more chances to
# collect the object before marking it expired, but uses more memory in the
# application server process.  Decreasing this value makes it more likely
# that the Agent will expire the live object before it is collected, but
# uses less memory.
LiveObjectLifespanLimit = 900;

# The maximum number of live objects that will be tracked by Agents.  Increasing
# this value allows the Agent to track more live objects concurrently, but uses
# more memory in the application server process.  Decreasing this value makes
# it more likely that the Agent will expire the live object before it is
# collected, but uses less memory.
LiveObjectCountLimit = 524288;

# The maximum size of request parameters that will be collected for request
# traces.
MaxTraceValueSize = 128;

# Exclusion list for request parameters that are considered sensitive, and
# should be ignored when collecting request traces.  Note that this has no
# effect on request separation.  This list may contain strings or regular
# expressions.
TraceParameterExclusions = (
	# Case-insensitive match for "name"
	/[Nn][Aa][Mm][Ee]/,

	# Case-insensitive match for "address"
	/[Aa][Dd][Dd][Rr][Ee][Ss][Ss]/,

	# Case-insensitive match for "password"
	/[Pp][Aa][Ss][Ss][Ww][Oo][Rr][Dd]/,

	# Case-insensitive match for /credit.*card/
	/[Cc][Rr][Ee][Dd][Ii][Tt].*[Cc][Aa][Rr][Dd]/,

	# Case-insensitive match for /social.*insurance/
	/[Ss][Oo][Cc][Ii][Aa][Ll].*[Ii][Nn][Ss][Uu][Rr][Aa][Nn][Cc][Ee]/,

	# Case-insensitive match for /social.*security/
	/[Ss][Oo][Cc][Ii][Aa][Ll].*[Ss][Ee][Cc][Uu][Rr][Ii][Tt][Yy]/,

	# Case-insensitive match for "passport"
	/[Pp][Aa][Ss][Ss][Pp][Oo][Rr][Tt]/,

	# Case-insensitive match for "licence" or "license"
	/[Ll][Ii][Cc][Ee][Nn][CScs][Ee]/,
);

SamplingOverhead = 1.0;