Gatling's Cheat sheet

Click on a DSL element to know how to use it and what it does

Scenario definition Describe your users behaviour

Scenario

Declares a new scenario
(name)
name is the scenario name in the reports

Conditions

Executes a chain when a condition is satisfied
(condition){chain}
If the result of the condition is true, then chain is executed.
(Session => Boolean){chain}
If the result of the function Session => Boolean is true, then chain is executed.
Executes a chain when a condition is satisfied, another if not
(condition){chain}{otherChain}
If the result of the condition is true, then chain is executed, else otherChain is executed.
(Session => Boolean){chain}{otherChain}
If the result of the function Session => Boolean is true, then chain is executed, else otherChain is executed.
Executes a chain when two values are equal
(expected, actual){chain}
If expected equals actual, then chain is executed
Executes a chain when two values are equal, another if not
(expected, actual){chain}{otherChain}
If expected equals actual, then chain is executed, else otherChain is executed.
Executes a chain based on a key
(key){switch}
Switch is selected through the matching of a key with the evaluation of the passed expression. If no switch is selected, switch is bypassed.
Executes a chain based on a key or a fallback chain
(key){switch}{chain}
Switch is selected through the matching of a key with the evaluation of the passed expression. If no switch is selected, chain is executed
Current user will continue in one of the specified weighted chains. Can be used to simulate simple Markov chains
(Map[%,Chain])
The Map contains the distribution of the randomSwitch. Each chain is weighted with a percentage. Make sure the sum of weights does not exceed 100.
Current user will continue in one of the specified weighted chains. Can be used to simulate simple Markov chains. Fallback available if no switch is selected
(Map[%,Chain]){chain}
The Map contains the distribution of the randomSwitch. Each chain is weighted with a percentage. Make sure the sum of weights does not exceed 100. If no switch is selected then chain is executed.
Current user will continue in one of the uniform distributed chains. Can be used to simulate simple Markov chains
(chains...)
The list of chains.
A round-robin strategy is used to determine the chain to be executed.
(chains...)
The list of chains.

Base structures

Execution Step
(action)
The action that will be executed at this step.
(chain...)
Inserts the chain(s) at this point of the scenario
(Session => Session)
Perform an operation upon the session at this step
Group related requests together
(groupName){chain}
Actions from chain are part of the group named groupName
Declares a fixed or random pause in the scenario
(dur unit)
The pause will last duration
(duration, timeunit)
Declares a pause duration with a specific timeunit
(dur unit, dur unit)
Declares a pause duration randomly selected between the two durations
(duration, duration, timeunit)
Declares a pause randomly selected between the two durations with a specific time timeunit
Pause which adjusts its wait time depending on how long the chained action took
(dur unit)
The pause will last duration
(duration, timeunit)
Declares a pause duration with a specific timeunit
(dur unit, dur unit)
Declares a pause duration randomly selected between the two durations
(duration, duration, timeunit)
Declares a pause randomly selected between the two durations with a specific time timeunit
Pauses users until all other users have reached the rendez-vous point
(userNumber)
Number of users to wait for

Loops

Repeats a part of the scenario
(counterName){chain}
The chain is repeated forever. Forcing the counter name with counterName is optional
Repeats a part of the scenario
(times){chain}
The chain is repeated the specified number of times
(times, counterName){chain}
The chain is repeated the specified number of times with a forced counter name
Repeats a part of the scenario
(dur unit){chain}
The chain is repeated for at least dur unit
(dur unit, counterName){chain}
Same as above with forced counter name
Repeats a part of the scenario
(condition){chain}
The chain is repeated as long as the condition is satisfied
(condition, counterName){chain}
Same as above with forced counter name
Repeats a part of the scenario
(sequence, elementName){chain}
The chain is repeated for every element in the sequence and the current element is stored in the Session under the elementName key
(sequence, elementName, counterName)
Same as above with forced counter name

Failure handling

Retries a chain until it succeeds
(times){chain}
chain will be repeated until either all checks in it are OK; or the chain has been repeated times times.
Stops block execution if a check fails
{chain}
If a check in chain fails, its execution is stopped and the scenario continues.
If there were an error during execution, the scenario should stop at this point.

Simulation configuration Tune your simulation

Throttling

Allows to reason in terms of request per second and not in terms of users. Can also be defined at the scenario level. Throttle can take one to many building blocks described below.
(reachRps(target) in (dur unit))
Target a throughput with a ramp over a given duration
(jumpToRps(target))
Jump immediately to a given targeted throughput
(holdFor(duration))
Hold the current throughput for a given duration
Eg: setUp(...).throttle(reachRps(100) in (10 seconds), holdFor(10 minute))

Time

Allows to configure pauses. Can also be defined at the scenario level
(disablePauses)
Disable the pauses for the simulation
(constantPauses)
Default value. Durations are precisely those filled in the pause(duration) elements.
(exponentialPauses)
Pause durations are on average those filled in the pause(duration) elements and follow an exponential distribution.
(customPauses(pauseDur))
Pauses durations are computed by the provided pauseDur. In this case the filled duration is bypassed
(uniformPauses(plusOrMinus))
Pause durations are on average those filled in the pause(duration) elements and follow an uniform distribution.
Allows to configure the maximum duration of your simulation
(maxDuration)
The maximum duration of the simulation

Feeder definition Inject data in your scenario

Feeder types

Declares a feeder from a CSV file
(fileName)
fileName is the name of the file under the data folder containing the comma separated values to be injected
Declares a feeder from a TSV file
(fileName)
fileName is the name of the file under the data folder containing the tabulation separated values to be injected
Declares a feeder from a SSV file
(fileName)
fileName is the name of the file under the data folder containing the semi-colon separated values to be injected
Declares a feeder from a JSON file
(fileName)
fileName is the name of the file under the data folder containing JSON file to be injected
Declares a feeder from a JSON url
(url)
url is the url returning the JSON array to be injected
Declares a feeder from database records
(dbURL,user,pass,sql)
The feeder will load its values thanks to the sql request made on the database located at the JDBC URL dbURL as user/pass.
Note that you need to include the right JDBC4 driver in the classpath (lib folder if using the bundle)
(pool, key)
This feeder loads its values from a Redis pool and stores them under key in the session.

Feeder strategies

This is the default strategy (you don't have to specify it). It takes the values in the feeder as in a queue. If the queue is not long enough, you'll get an error at execution.
This strategy shuffles the values in the feeder but then works like the queue strategy.
This strategy chooses values randomly in the feeder. In contrast to a shuffle strategy the same values can be chosen several times.
This strategy takes the values of the feeder in their order, and when it reaches the last, it returns to the first one.

Injection profile Control how users are injected in your scenario

Injection steps

Pauses for a specific duration
(dur unit)
Pause for a given duration
Injects a specific number of users at the same time
(nbUsers)
Injects nbUsers
Injects a given number of users with a linear ramp over a given duration
(nbUsers) over(dur unit)
Injects nbUsers over a duration. Eg : rampUsers(10) over(5 seconds)

 

Injects users at a constant rate, defined in users per second, during a given duration
(nbUsers) during(dur unit)
Injects nbUsers each second for duration. Eg : constantUsersPerSec(10) during(5 seconds)
Injects a random number of users per second over a given duration
(rate1) to (rate2) during(dur unit)
Injects users from starting rate1 to target rate2, defined in users per second, during a given duration. Eg : rampUsersPerSec(10) to(20) during(10 minutes)
Repeats an injection until reaching desired number of users
(nbUsers) into(injectionStep) separatedBy(dur unit)
Repeats the defined injection step separated by a pause of the given duration until reaching nbUsers
(nbUsers) into(injectionStep1) separatedBy(injectionStep2)
Repeats the first defined injection step injectionStep1 separated by the execution of the second injection step injectionStep2 until reaching nbUsers
Injects a given number of users following a smooth approximation stretched to a duration
(nbUsers) over(dur unit)
Injects a given number of users following a smooth approximation of the Heaviside step function stretched to a given duration

Assertions Check that your results match your expectations

Assertions

Declare the assertions on your simulation
(assertions)
The assertions your simulation will be checked against

Scopes

Use statistics calculated from all requests
Use statistics calculated for each individual request.
Use statistics calculated from a group or a request
(path)
The request or group path

Statistics

Target the response time in milliseconds
Target the number of requests
Target the number of failed requests
Target the number of successful requests
Target the rate of requests per second

Response time selectors

Perform the assertion on the minimum of the stat
Perform the assertion on the maximum of the stat
Perform the assertion on the mean of the stat
Perform the assertion on the standard deviation of the stat
Perform the assertion on the first percentile of the stat
Perform the assertion on the second percentile of the stat
Perform the assertion on the third percentile of the stat
Perform the assertion on the fourth percentile of the stat
Perform the assertion on the given percentile of the stat
(value)
The double value of percentile rank, between 0 and 100

Count selectors

Use the value as a percentage between 0 and 100
Use the value as a permillion between 0 and 1,000,000
Perform the assertion on the count of requests

Assertions conditions

Check that the value of the statistic is less than the threshold
(threshold)
the statistic's higher bound
Check that the value of the statistic is less than or equal to the threshold
(threshold)
the statistic's higher bound
Check that the value of the statistic is greater than the threshold
(threshold)
the statistic's lower bound
Check that the value of the statistic is greater than or equal to the threshold
(threshold)
the statistic's lower bound
Check that the value of the statistic is between two thresholds
(thresholdMin,thresholdMax)
the statistic's bounds
(thresholdMin,thresholdMax, inclusive = false)
the statistic's bounds, excluded
Check that the value of the statistic is equal to the given value
(value)
the value the statistic must be equal to
Check that the value of statistic is in a sequence
(sequence)
the sequence the statistic has to be in

HTTP Action Define the HTTP requests sent in your scenario

HTTP

Declares an HTTP request
(name)
name is the request name in the reports

HTTP verb

Sets the HTTP method to GET
(url)
Sets the url of the HTTP request
Sets the HTTP method to POST
(url)
Sets the url of the HTTP request
Sets the HTTP method to PUT
(url)
Sets the url of the HTTP request
Sets the HTTP method to DELETE
(url)
Sets the url of the HTTP request
Sets the HTTP method to HEAD
(url)
Sets the url of the HTTP request
Sets the HTTP method to PATCH
(url)
Sets the url of the HTTP request
Sets the HTTP method to OPTIONS
(url)
Sets the url of the HTTP request
Support for custom HTTP methods
(method, url)
Executes method on url
Support for custom methods extending POST
(method, url)
Executes method on url

HTTP options

Adds a query parameter to the URL
(key, value)
http://example.tld?key=value
Adds a query parameter to the URL with multiple values
(key, value...)
http://example.tld?key=value1&key=value2&key=value3...
Adds multiple query parameters to the URL
((key, value)...)
http://example.tld?key1=value1&key2=value2&key3=value3...
Adds multiple query parameters to the URL
(Map[key -> value])
http://example.tld?key1=value1&key2=value2&key3=value3...
Adds a header to the request.
(key, value)
Adds key: value as header
Adds several headers to the request.
(Map[key, value])
Adds every tuple key: value of the map as header
Sets the credentials for BASIC authentication
(user, password)
Will authenticate as user with password
Sets the credentials for DIGEST authentication
(user, password)
Will authenticate as user with password
Sets the credentials for NTLM authentication
(user, password)
Will authenticate as user with password
Generic method to add authentication
(Realm)
Takes a Realm instance
Allows to fetch resources in parallel in order to emulate the behaviour of a real web browser
(request...)
Multiple requests to get resources
Disable URLEncoding if you're sure the urls you feed to Gatling are already properly encoded.
Forces the request to be silent A silent request is issued but not logged nor reported
Forces the request to NOT be silent, whatever's defined at protocol level. A silent request is issued but not logged nor reported

HTTP body

Adds a body from a resource to the request
(RawFileBody(path))
Uploads a file as is from the path
(ELFileBody(path))
Parses, resolves and then uploads a file containing Gatling EL from the path
(StringBody(string))
Sets a string
(ByteArrayBody(bytes))
Sets the body from a bytes array
(InputStreamBody(stream))
Sets the body from an input stream
Add a multi-part body from a resource to the request
(RawFileBodyPart(path))
Uploads a file as is from the path
(ELFileBodyPart(path))
Parses, resolves and then uploads a file containing Gatling EL from the path
(StringBodyPart(string))
Sets a string
(ByteArrayBodyPart(bytes))
Sets the body from a bytes array
Adds a form parameter to the request body
(key, value)
Where key is the name and value is a string
(HttpParam)
Where HttpParam is an instance of HttpParam
Adds a form parameter to the request body with multiple values
(key, value...)
Where key is the name of one parameter and value can be a list
Adds multiple form parameters to the request body
((key, value)...)
Where you can have multiple tuples of key and value
Adds multiple form parameters to the request body
(Map[key -> value])
Where you can have a map of multiple key and value
Adds a form to the request body
(Map[key -> Seq[value]])
Typically saved by a form check
Allows to process the response before it is sent to the checks pipeline.
(ResponseTransformer)
Takes a ResponseTransformer, which is a Response => Response function
Allows to process the request body before it is sent to the wire
(processor)
Takes a processor which is a Body => Body function
Provides a multi-part encoded request when you need to upload a file corresponding to a form text value. Eg: Email attachment
(key, filePath)
Where key is the name of the field and filePath a path to a file located in /bodies

HTTP Checks Verifying server responses

Check

Declare every check that should apply on the action
(check...)
Every check you need to make on the response from the server

 

Check will be applied to an extract of the HTTP response's body
(expression)
Extraction will look for expression indices.
Check will be applied to an extract of the HTTP response's body
(expression)
Extraction will use a regular expression defined by expression.
Check will be applied to an extract of the HTTP response's body
(expression)
Extraction will use an XPath expression defined by expression
(expression, namespaces)
If you want to use namespaces in your XPATH expression, you should specify them. The namespaces are specified thanks to a List[(prefix,uri)]:
List(('c','http://core'), ('f','http://format')).
(Session => String)
The expression can be expressed as a Session => String function (with namespaces also)
Check will be applied to an extract of the HTTP response's body
(expression)
jsonPath is similar to XPATH, but for JSON encoded data.
Check will be applied to an extract of the HTTP response's body
(expression)
jsonpJsonPath is similar to jsonPath, but for JSONP
Check will be applied to an extract of the HTTP response's body
(expression)
Uses the css selector to extract the value to be checked.
(expression, attr)
Same as above, except that the extracted value is the attr of the selected node.
Check will be applied to an extract of the HTTP response's body
(expression)
Uses the css selector to extract the all the field values of an HTML form.
Check will be applied on the md5 checksum of the HTTP response
Check will be applied on the sha1 checksum of the HTTP response

Http checks

Check will be applied to the status of the HTTP response
Check will be applied to the current url of the response
Check will be applied to selected headers of the HTTP response
(headerName)
The check will be applied on the header corresponding to headerName
(Session => String)
Same as above, except that the header name is given by the Session => String function.
Check will be applied to selected headers of the HTTP response
(headerName, pattern)
The check will be applied on the headers headerName whose value match the provided pattern.
(Session => String)
Same as above, except that the header name is given by the Session => String function.
Check will be applied to the response time of the server
Check will be applied to the latency of the request/response round trip
Return the full response body String.
Return the full response body byte array.

CheckIf

Enslave check execution to a condition
checkIf(condition: Expression[Boolean])(thenCheck: Check)
Only perform thenCheck if condition evaluates to true
checkIf(condition: (Response, Session) => Validation[Boolean])(thenCheck: Check)
Only perform thenCheck if condition return true

Check extractors

Specifies that only one value matching the check definition must be extracted
ø
If used as find check will be applied on the first value found. Note that this is the default behaviour, you don't have to specify it.
(occurrence)
Gets the occurrence-th value that matches the check definition.
Specifies that every value matching the check definition should be extracted for verification. The resulting type is a list of extracted values.
Fetches random matches.
ø
If used as findRandom fetches one single match, returns a single value.
(num: Int)
Fetches a given number of occurrences, returns a Seq.
(num: Int, failIfLess: Boolean)
Same as above, but fails if the number of actual matches is less than num.
The check will be applied on the size of the list returned by findall

Check transformer

Used to transform data before verification
(A => B)
This function is optional. It can be useful sometimes to apply a transformation on the extracted values before validating them. In this function, type A is the type of the find operation (either String, List[String] or Int). Type B is whatever you want it to be (could be a case class for example)
Used to transform data before verification
(Option[A] => Validation[Option[B]])
Gives full control over the extracted result, even providing a default value

Check verifiers

Checks for equality
(expected)
if the captured (or transformed) value is equal to expected the check will succeed; it will fail otherwise
Checks for inequality
(expected)
If the captured (or transformed) value is different than expected the check will succeed; it will fail otherwise
Checks that there's at least one value corresponding to the check definition .This is the default verification (it does not need to be specified)
Checks that there are no values corresponding to the check definition
Checks for belonging to a sequence
(sequence)
If the captured (or transformed) value is included in the sequence the check will succeed; it will fail otherwise
Never fails, used to capture optional values into the session

Check saver

If the check succeeds, it captures the extracted value(s) into the session
(key)
The value(s) will be stored in the session under key key

HTTP Protocol Mutualize your scenario's code and tune the behaviour of Gatling's HTTP client

Protocol

Entry point of your HTTP protocol

Urls

Sets the base URL of all relative URLs of the scenario on which the configuration is applied
(url)
The url that will be appended to all relative URLs (ie: not starting with http)
Same as baseURL with client-based load balancing.
(url...)
Each url will be used randomly to implement client load-balancing.
Overrides the default computed virtual host
(name)
Eg: GET https://mobile.github.com/gatling/gatling instead of GET https://www.github.com/gatling/gatling

Proxy

Declares a proxy for all HTTP requetes of the scenario on which the configuration is applied
(Proxy)
The requests will pass throught the proxy located within the Proxy object
Disables the proxy for a certain list of hosts
(hosts)
The hosts ignoring the proxy
Uses this if Gatling should use the proxy for HTTPS also
(port)
The HTTPS port of the proxy
If your proxy requires BASIC authentication you can set the credentials with this method
(username,password)
The requests will be sent as the user username/password

Headers

Sets the Accept header for all requests
(value)
The value of the header.
Sets the Accept-Charset header for all requests
(value)
The value of the header
Sets the Accept-Encoding header for all requests
(value)
The value of the header
Sets the Accept-Language header for all requests
(value)
The value of the header
Sets the Authorization header for all requests
(value)
The value of the header
Sets the Connection header for all requests
(value)
The value of the header
Sets the Content-Type header for all requests
(value)
The value of the header
Sets the DNT header for all requests
(value)
The value of the header.
Sets the User-Agent header for all requests
(value)
The value of the header

Options

Forces the HTTP engine not to follow the redirects. You can also disable it globally on the HttpProtocol
Avoids infinite redirection loops by specifying a number max of redirects
(max)
Where max is the number of max redirects
Forces Gatling not to set the referer of the requests
Disables the warm up request
Sets the URL used by Gatling to warm up the HTTP engine
(url)
A valid and accessible url
Ignores checks for a given request. You can also disable common checks that were defined on the HttpProtocol
Allows to fetch resources in parallel in order to emulate the behaviour of a real web browser
(WhiteList)
Fetch all resources matching a pattern in the white list
(WhiteList, BlackList)
Fetch all resources matching a pattern in the white list excepting those in the black list
(Filters)
More generic version taking any kind of filters
Sets the maximum concurrent connections per host per virtual user. Predefined parameters are available through methods such as maxConnectionsPerHostLikeFirefox...
(max)
Where max is the number of maximum connections
Allows to share connections among users
Enables one http client per user
Enables virtual users to perform name resolution themselves instead of using JDK's shared one.

 

Binds the sockets from a specific local address instead of the default one
(InetAddress)
Instance of InetAddress representing the address
Disables caching features for some http headers and ETag
Disable URLEncoding if you're sure the urls you feed to Gatling are already properly encoded.
Silence requests that match the pattern A silent request is issued but not logged nor reported
(String)
A regular expression pattern to match request urls
Silence resource requests A silent request is issued but not logged nor reported
Sets the credentials for BASIC authentication
(user, password)
Will authenticate as user with password
Sets the credentials for DIGEST authentication
(user, password)
Will authenticate as user with password
Sets the credentials for NTLM authentication
(user, password)
Will authenticate as user with password
Generic method to add authentication
(Realm)
Takes a Realm instance

Plumbing

Dumps additional data into simulation.log during the simulation
(ExtraInfo => List[Any])
The function is used by Gatling to add several columns containing extra info to the simulation log file.
ExtraInfo provides :
  • requestName: The request's name
  • status: The request's status (OK or KO)
  • session: The user's session
  • request: The sent request
  • response: The received response
If you want the body of the response to be kept when using extraInfoExtractor, you'll have to disable response chunk discard (which is a performance optimization)

SSE (Server Sent Events) Define the SSE requests sent in your scenario

SSE

Declares an SSE request
(requestName)
Name of the request

Commons

Allows to deal with several SSE per virtual user
(requestName)
Gives the requests a name and pass this name on each SSE operation
Opens a SSE
(url)
Enables communication to the given url
Closes a SSE

WebSockets Define the WebSocket requests sent in your scenario

WebSocket

Declares an webSocket request
(requestName)
Name of the request

Commons

Allows to deal with several webSockets per virtual user
(requestName)
Gives the requests a name and pass this name on each ws operation
Opens a webSocket
(url)
Enables communication to the given url
Closes a webSocket
Sends a message
(stringMessage)
Send stringMessage as a string
(bytesMessage)
Send bytesMessage as a bytes array

WebSockets/SSE Checks Verifying server responses

Checks

Cancels a pending check
Creates a non blocking check
Creates a blocking check
Sets a timeout
(timeout)
Where timeout is a FiniteDuration instance
Checks will succeed as soon as Gatling has received the expected count of matching messages
(count)
Where count is the number of matching messages

 

Waits until the timeout, then the check will succeed if it has received the expected count of matching messages
(count)
Where count is the number of matching messages
(range)
Where range is an instance of Range
Check will be applied to an extract of the frame payload
(expression)
Extraction will use a regular expression defined by expression.
Check will be applied to an extract of the frame payload
(expression)
jsonPath is similar to XPATH, but for JSON encoded data.
Check will be applied to an extract of the frame payload
(expression)
jsonpJsonPath is similar to jsonPath, but for JSONP
Reconciliates main flow and WebSocket/SSE flow

WebSockets Configuration Mutualize your webSockets code and tune the behaviour of Gatling's webSocket client

Configuration

Serves as root that will be prepended to all relative webSocket urls
(url)
Where url is the root url
Serves as round-robin roots that will be prepended to all relative webSocket urls
(url...)
Where url are the root urls
Automatically reconnect a webSocket that would have been closed by someone else than the client
Sets a limit on the number of times a webSocket will be automatically reconnected
(count)
Where count is the number of maximum reconnections url

JMS Define the JMS requests sent in your scenario

Start

Declares an JMS request
(requestName)
Name of the request

Commons

Sets the messaging implementation to request/reply
Sets the messaging implementation to send
Defines a target destination
(name)
Where name is the name of the queue
Defines a target destination
(destination)
Where destination is an instance of JmsDestination
Defines a reply destination
(name)
Where name is the name of the queue
Defines a reply destination
(destination)
Where destination is an instance of JmsDestination
Defines a JMS message selector
(selector)
Where selector is the name of the selector

 

Sends a text message
(textMessage)
Where textMessage is a string
Sends a byte message
(bytesMessage)
Where bytesMessage is a byte array
Sends a map message
(mapMessage)
Where mapMessage is a map
Sends an object message
(objectMessage)
Where objectMessage is an object implementing JSerializable
Sends additional properties
(key, value)
Sets value as an object property key
Sends additional properties
(value)
Sets value as a JMSType

JMS Checks Verifying server responses

Checks

Allows to check a message
(function)
Where function takes a Message and returns a Boolean
Allows to check a TextMessage with XPath
(expression)
Where expression is an XPath expression

JMS Configuration Configure how Gatling connects to your JMS queues

Configuration

Entry point of your JMS configuration

Connecting

Mandatory.

Set the name of the ConnectionFactory to use
(name)
where name is a string

Mandatory.

Set the URL of the queue to connect to.
(url)
where url is a string

Mandatory.

Set the name of the JNDI ContextFactory to use.
(contextFactory)
where contextFactory is a string

Optional.

Set the credentials used for the queues JNDI lookup
(username, password)
the username and password to use as credentials

Optional.

Use credentials for opening connections too

Mandatory. must be > 0.

Number of consumers that will listen to incoming messages on the reply queue
(listenerCount)
The number of consumers

Delivery modes

Use JMS' non-persistent delivery mode (active by default)
Use JMS' persistent delivery mode

Message matching

Match request and response using JMS's MessageID
Match request and response using JMS's CorrelationID
Match request and response using a custom strategy
(messageMatcher)
an implementation of JmsMessageMatcher, specifying how the requestID and responseID are retrieved from the JMS Message