Azure Logic App (Consumption) is one of the most used integration services for orchestrating critical workflows, and an error in it would essentially affect your business continuity.

By default, Logic App allows handling errors using the Configure run after settings at a per action level. For more complex scenarios, it can be done by setting up Scope action and implementing try-catch or try-catch-finally statements.

This video aims to explain and discuss error handling within Logic Apps and explore the implementation of a try-catch-finally statement. Even though we are using Logic Apps Consumption for this proof of concept, the same principles will be applied to Logic Apps Standard.

Hope you find this helpful! So, if you liked the content or found it useful and want to help me write more content, you can buy (or help buy) my son a Star Wars Lego!

Big thanks to my team member Luís Rigueira for creating this video.

Author: Sandro Pereira

Sandro Pereira lives in Portugal and works as a consultant at DevScope. In the past years, he has been working on implementing Integration scenarios both on-premises and cloud for various clients, each with different scenarios from a technical point of view, size, and criticality, using Microsoft Azure, Microsoft BizTalk Server and different technologies like AS2, EDI, RosettaNet, SAP, TIBCO etc.

He is a regular blogger, international speaker, and technical reviewer of several BizTalk books all focused on Integration. He is also the author of the book “BizTalk Mapping Patterns & Best Practices”. He has been awarded MVP since 2011 for his contributions to the integration community.
View all posts by Sandro Pereira

Because the Math (or Mathematical) functions category has too many functions, I decide to break this blog post into different parts, so welcome to the second part!

Overview

Math (or Mathematical) functions are used to perform a variety of mathematical and scientific operations, such as addition and multiplication. If you come from the BizTalk Server background or are migrating BizTalk Server projects, they are the equivalent of Mathematical and Scientific Functoids inside BizTalk Mapper Editor.

Available Functions

The Math functions are:

Absolute: Returns the absolute value of the specified number.

Add: Returns the sum from adding two or more numbers.

Arctangent: Returns the arc tangent of a number.

Ceiling: Returns the smallest integral value greater than or equal to the specified number.

Cosine: Returns the cosine for the specified angle.

Divide: Returns the result from dividing two numbers.

Exponential: Raises the “e” constant to the specified power and returns the result.

Exponential (base 10): Returns the number 10 raised to the specified power.

Floor: Returns the largest integral value less than or equal to the specified number.

Integer divide: Divides two numbers and returns the integer part from the result.

Log: Returns the logarithm for the specified number in the specified base.

Log (base 10): Returns the base 10 logarithm for the specified number.

Modulo: Returns the remainder from dividing the specified numbers.

Multiply: Returns the product from multiplying two or more specified numbers.

Power: Returns the specified number raised to the specified power.

Round: Rounds a value to the nearest integer or the specified number of fractional digits and returns the result.

Square root: Returns the square root for the specified number.

Subtract: Subtracts the second number from the first number and returns the result.

Tangent: Returns the tangent for the specified angle.

Log

This function states that it will return the logarithm for the specified number in the specified base.

Behind the scenes, this function is translated to the following XPath function: math:log($arg)

math:log($arg as xs:double?) as xs:double?

Rules:

The result is the natural logarithm of $arg

Sample:

The expression math:log(0) returns xs:double('-INF').

The expression math:log(-1) returns xs:double('NaN').

The expression math:log(2) returns 0.6931471805599453

Log (base 10)

This function states that it will return the base 10 logarithm for the specified number.

Behind the scenes, this function is translated to the following XPath function: math:log10($arg)

math:log10($arg as xs:double?) as xs:double?

Rules:

The result is the base-10 logarithm of $arg

Sample:

The expression math:log10(0) returns xs:double('-INF')

The expression math:log10(2) returns 0.3010299956639812

The expression math:log10(-1) returns xs:double('NaN')

Modulo

This function states that it will return the remainder from dividing the specified numbers.

Behind the scenes, this function is translated to the following XPath expression: ($arg1) mod ($arg2)

fn:error($code as xs:QName?, $description as xs:string) as none

Rules:

Returns the remainder resulting from dividing $arg1, the dividend, by $arg2, the divisor.

The operation a mod b for operands that are xs:integer or xs:decimal, or types derived from them, produces a result such that (a idiv b)*b+(a mod b) is equal to a and the magnitude of the result is always less than the magnitude of b. This identity holds even in the special case that the dividend is the negative integer of largest possible magnitude for its type and the divisor is -1 (the remainder is 0). It follows from this rule that the sign of the result is the sign of the dividend.

Sample:

The expression (10) mod (3) returns 1.

The expression (6) mod (-2) returns 0.

The expression (4.5) mod (1.2) returns 0.9.

Multiply

This function states that it will return the product from multiplying two or more specified numbers.

Behind the scenes, this function is translated to the following XPath expression: ($arg1) * ($arg2) (allows more inputs)

($arg1) * ($arg2) as xs:numeric?

Rules:

Returns the arithmetic product of its operands: ($arg1 * $arg2).

For the four types xs:float, xs:double, xs:decimal and xs:integer, it is guaranteed that if the type of $arg is an instance of type T then the result will also be an instance of T. The result may also be an instance of a type derived from one of these four by restriction. For example, if $arg is an instance of xs:decimal then the result may be an instance of xs:integer.

This function allows two or more inputs.

Sample:

The expression (5) + (2) returns 10.

The expression (5.1) + (2) returns 10.2.

Power

This function states that it will return the specified number raised to the specified power.

Behind the scenes, this function is translated to the following XPath function: math:pow($arg1, $arg2)

math:pow($arg1 as xs:double?, $arg2 as xs:numeric) as xs:double?

Rules:

If $arg2 is an instance of xs:integer, the result is $arg1 raised to the power of $arg2. Otherwise $arg2 is converted to an xs:double by numeric promotion, and the result is the value of $arg1 raised to the power of $arg2.

Sample:

The expression math:pow(2, 3) returns 8.

The expression math:pow(-2, 3) returns -8

The expression math:pow(2, 0) returns 1

The expression math:pow(2.5, 2) returns 6.25

Round

This function states that it will round a value to the nearest integer or the specified number of fractional digits and returns the result.

Behind the scenes, this function is translated to the following XPath function: round($arg1, $arg2)

fn:round($arg as xs:numeric?, $precision as xs:integer) as xs:numeric?

Rules:

The function returns the nearest (that is, numerically closest) value to $arg that is a multiple of ten to the power of minus $precision. If two such values are equally near (for example, if the fractional part in $arg is exactly .5), the function returns the one that is closest to positive infinity.

For the four types xs:float, xs:double, xs:decimal and xs:integer, it is guaranteed that if the type of $arg is an instance of type T then the result will also be an instance of T. The result may also be an instance of a type derived from one of these four by restriction. For example, if $arg is an instance of xs:decimal and $precision is less than one, then the result may be an instance of xs:integer.

Sample:

The expression fn:round(1.125, 2) returns 1.13

The expression fn:round(8452, -2) returns 8500

Sine

This function states that it will return the sine for the specified angle.

Behind the scenes, this function is translated to the following XPath function: math:sin($arg)

math:sin($arg as xs:double?) as xs:double?

Rules:

If $arg is positive or negative zero, the result is $arg.

Returns the sine of the argument. The argument is an angle in radians.

Sample:

The expression math:sin(0) returns 0.

The expression math:sin(45) returns 0.8509035245341184.

Square root

This function states that it will return the square root for the specified number.

Behind the scenes, this function is translated to the following XPath function: math:sqrt($arg)

math:sqrt($arg as xs:double?) as xs:double?

Rules:

If $arg is positive or negative zero, positive infinity, or NaN, then the result is $arg. (Negative zero is the only case where the result can have negative sign)

The result is the mathematical non-negative square root of $arg

Sample:

The expression math:sqrt(0) returns 0.

The expression math:sqrt(-2) returns NaN.

The expression math:sqrt(4) returns 2.

Subtract

This function states that it will subtract the second number from the first number and returns the result.

Behind the scenes, this function is translated to the following XPath function: ($arg1) - ($arg2)

($arg1 as xs:numeric - $arg2 as xs:numeric) as xs:numeric

Rules:

Returns the arithmetic difference of its operands: ($arg1 - $arg2).

$arg1 and $arg2 are numeric values (xs:float, xs:double, xs:decimal and xs:integer)

Sample:

The expression (3) - (1) returns 2.

The expression (2) - (1.12) returns 0.88.

Tangent

This function states that it will return the tangent for the specified angle.

Behind the scenes, this function is translated to the following XPath function: math:tan($arg)

math:tan($arg as xs:double?) as xs:double?

Rules:

If $arg is positive or negative infinity, or NaN, then the result is NaN.

Returns the tangent of the argument. The argument is an angle in radians.

Sample:

The expression math:tan(0) returns 0

The expression math:tan(12) returns -0.6358599286615808

Hope you find this helpful! So, if you liked the content or found it useful and want to help me write more, you can buy (or help buy) my son a Star Wars Lego!

Author: Sandro Pereira

Sandro Pereira lives in Portugal and works as a consultant at DevScope. In the past years, he has been working on implementing Integration scenarios both on-premises and cloud for various clients, each with different scenarios from a technical point of view, size, and criticality, using Microsoft Azure, Microsoft BizTalk Server and different technologies like AS2, EDI, RosettaNet, SAP, TIBCO etc.

He is a regular blogger, international speaker, and technical reviewer of several BizTalk books all focused on Integration. He is also the author of the book “BizTalk Mapping Patterns & Best Practices”. He has been awarded MVP since 2011 for his contributions to the integration community.
View all posts by Sandro Pereira

Math (or Mathematical) functions are used to perform a variety of mathematical and scientific operations, such as addition and multiplication. If you come from the BizTalk Server background or are migrating BizTalk Server projects, they are the equivalent of Mathematical and Scientific Functoids inside BizTalk Mapper Editor.

Available Functions

The Math functions are:

Absolute: Returns the absolute value of the specified number.

Add: Returns the sum from adding two or more numbers.

Floor: Returns the largest integral value less than or equal to the specified number.

Integer divide: Divides two numbers and returns the integer part from the result.

Log: Returns the logarithm for the specified number in the specified base.

Log (base 10): Returns the base 10 logarithm for the specified number.

Modulo: Returns the remainder from dividing the specified numbers.

Multiply: Returns the product from multiplying two or more specified numbers.

Power: Returns the specified number raised to the specified power.

Round: Rounds a value to the nearest integer or the specified number of fractional digits and returns the result.

Sine: Returns the sine for the specified angle.

Square root: Returns the square root for the specified number.

Subtract: Subtracts the second number from the first number and returns the result.

Tangent: Returns the tangent for the specified angle.

Absolute

This function states that it will return the absolute value of the specified number.

Behind the scenes, this function is translated to the following XPath function: abs($arg)

fn:abs($arg as xs:numeric?) as xs:numeric?

Rules:

If $arg is negative, the function returns -$arg. Otherwise, it returns $arg.

For the four types xs:float, xs:double, xs:decimal and xs:integer, it is guaranteed that if the type of $arg is an instance of type T then the result will also be an instance of T. The result may also be an instance of a type derived from one of these four by restriction. For example, if $arg is an instance of xs:positiveInteger then the value of $arg may be returned unchanged.

For xs:float and xs:double arguments, if the argument is positive zero or negative zero, then positive zero is returned. If the argument is positive or negative infinity, positive infinity is returned.

Sample:

The expression fn:abs(10.5) returns 10.5.

The expression fn:abs(-10.5) returns 10.5.

Add

This function states that it will return the sum from adding two or more numbers.

Behind the scenes, this function is translated to the following XPath expression: $arg1 + $arg2 (allows more inputs)

($arg1 as xs:numeric + $arg2 as xs:numeric) as xs:numeric

Rules:

Returns the arithmetic sum of its operands: ($arg1 + $arg2).

$arg1 and $arg2 are numeric values (xs:float, xs:double, xs:decimal and xs:integer)

This function allows two or more inputs.

Sample:

The expression (1) + (3) returns 4.

The expression (1.12) + (2) returns 3.12.

Arctangent

This function states that it will return the arc tangent of a number.

Behind the scenes, this function is translated to the following XPath function: math:atan($arg)

math:atan($arg as xs:double?) as xs:double?

Rules:

If $arg is a non-numeric value, then the result is empty.

Sample:

The expression math:atan(0) returns 0.

The expression math:atan(1.28) returns 0.9075933340888034.

Ceiling

This function states that it will return the smallest integral value greater than or equal to the specified number.

Behind the scenes, this function is translated to the following XPath function: ceiling($arg)

fn:ceiling($arg as xs:numeric?) as xs:numeric?

Rules:

The function returns the smallest (closest to negative infinity) number with no fractional part that is not less than the value of $arg.

For the four types xs:float, xs:double, xs:decimal and xs:integer, it is guaranteed that if the type of $arg is an instance of type T then the result will also be an instance of T. The result may also be an instance of a type derived from one of these four by restriction. For example, if $arg is an instance of xs:decimal then the result may be an instance of xs:integer.

Sample:

The expression fn:ceiling(10.5) returns 11.

The expression fn:ceiling(-10.5) returns -10.

Cosine

This function states that it will return the cosine for the specified angle.

Behind the scenes, this function is translated to the following XPath function: math:cos($arg)

math:cos($arg as xs:double?) as xs:double?

Rules:

If $arg is positive or negative zero, the result is $arg.

Sample:

The expression math:cos(0) returns 1

The expression math:cos(1212) returns 0.7931914936378434

Divide

This function states that it will return the result from dividing two numbers.

Behind the scenes, this function is translated to the following XPath function: $arg1 div $arg2

$arg1 div $arg2 as xs:numeric?

Rules:

For the four types xs:float, xs:double, xs:decimal and xs:integer, it is guaranteed that if the type of $arg is an instance of type T then the result will also be an instance of T. The result may also be an instance of a type derived from one of these four by restriction. For example, if $arg is an instance of xs:decimal then the result may be an instance of xs:integer.

Sample:

The expression (10) div (3) returns 3.

The expression (-3) div (-2) returns 1.5.

The expression (-3) div (2) returns -1.

The expression (-3.5) div (3) returns 0.7.

Exponential

This function states that it will raise the “e” constant to the specified power and returns the result.

Behind the scenes, this function is translated to the following XPath function: math:exp($arg)

math:exp($arg as xs:double?) as xs:double?

Rules:

Returns the value of e

Sample:

The expression math:exp(0) returns 1.

The expression math:exp(1) returns 2.7182818284590455.

Exponential (base 10)

This function states that it will return the number 10 raised to the specified power.

Behind the scenes, this function is translated to the following XPath function: math:exp10($arg)

math:exp10($arg as xs:double?) as xs:double?

Rules:

Returns the value of 10

Sample:

The expression math:exp10(0) returns 1

The expression math:exp10(1) returns 1.0e1.

The expression math:exp10(0.5) returns 3.1622776601683795

Floor

This function states that it will return the largest integral value less than or equal to the specified number.

Behind the scenes, this function is translated to the following XPath function: floor($arg)

fn:error($code as xs:QName?, $description as xs:string) as none

Rules:

The function returns the largest (closest to positive infinity) number with no fractional part that is not greater than the value of $arg.

For the four types xs:float, xs:double, xs:decimal and xs:integer, it is guaranteed that if the type of $arg is an instance of type T then the result will also be an instance of T. The result may also be an instance of a type derived from one of these four by restriction. For example, if $arg is an instance of xs:decimal then the result may be an instance of xs:integer.

Sample:

The expression fn:floor(10.5) returns 10.

The expression fn:floor(10.9) returns 10.

The expression fn:floor(-10.5) returns -11.

Integer divide

This function states that it will divide two numbers and returns the integer part from the result.

Behind the scenes, this function is translated to the following XPath expression: ($arg1) idiv ($arg2)

($arg1) idiv ($arg2) as xs:integer

Rules:

Performs an integer division.

For the four types xs:float, xs:double, xs:decimal and xs:integer, it is guaranteed that if the type of $arg is an instance of type T then the result will also be an instance of T. The result may also be an instance of a type derived from one of these four by restriction. For example, if $arg is an instance of xs:decimal then the result may be an instance of xs:integer.

Sample:

The expression (10) idiv (3) returns 3.

The expression (-3) idiv (-2) returns 1.

The expression (-3) idiv (2) returns -1.

The expression (-3.5) idiv (3) returns -1.

Stay tune for the second part of this blog post.

Hope you find this helpful! So, if you liked the content or found it useful and want to help me write more, you can buy (or help buy) my son a Star Wars Lego!

Author: Sandro Pereira

Sandro Pereira lives in Portugal and works as a consultant at DevScope. In the past years, he has been working on implementing Integration scenarios both on-premises and cloud for various clients, each with different scenarios from a technical point of view, size, and criticality, using Microsoft Azure, Microsoft BizTalk Server and different technologies like AS2, EDI, RosettaNet, SAP, TIBCO etc.

He is a regular blogger, international speaker, and technical reviewer of several BizTalk books all focused on Integration. He is also the author of the book “BizTalk Mapping Patterns & Best Practices”. He has been awarded MVP since 2011 for his contributions to the integration community.
View all posts by Sandro Pereira

String functions are used to manipulate strings in standard ways, such as conversions to all uppercase or all lowercase, string concatenation, determination of string length, white space trimming, etc. If you come from the BizTalk Server background or are migrating BizTalk Server projects, they are the equivalent of String Functoids inside BizTalk Mapper Editor.

Available Functions

The Conversion functoids are:

To DateTime: Returns the specified value as a DateTime value.

To integer: Returns the specified value as an integer.

To number: Returns the specified value as a number.

To string: Returns the specified value as a string.

To DateTime

This function states that it returns the specified value as a DateTime value.

Behind the scenes, this function is translated to a Type casting rule in XQuery: date()

date(string?)

Rules:

Castable values are restricted by the target types implementation restrictions. For example, you cannot cast a date string with a negative year to xs:date. Such casts will result in the empty sequence if the value is provided at run time (instead of raising a run-time error).

To integer

This function states that it returns the specified value as an integer.

Behind the scenes, this function is translated to the following XPath function: number()idiv 1

number($arg as xs:anyAtomicType?) as xs:doubleidiv 1

Note: idiv is an integer division operator. XPath supports two division operators named div and idiv. Each of these operators accepts two operands of any numeric type. $arg1 idiv $arg2 is equivalent to ($arg1 div $arg2) cast as xs:integer? except for error cases.

Rules:

If $arg is the empty sequence, or if $arg cannot be converted to an xs:double, the xs:double value NaN is returned.

Otherwise, $arg is converted to an xs:double following the rules of casting to xs:double. If the conversion to xs:double fails, the xs:double value NaN is returned.

To number

This function states that it returns the specified value as a number.

Behind the scenes, this function is translated to the following XPath function:: number()

number($arg as xs:anyAtomicType?) as xs:double

Rules:

If $arg is the empty sequence, or if $arg cannot be converted to an xs:double, the xs:double value NaN is returned.

Otherwise, $arg is converted to an xs:double following the rules of casting to xs:double. If the conversion to xs:double fails, the xs:double value NaN is returned.

To string

This function states that it returns the specified value as a string.

Behind the scenes, this function is translated to a Type casting rule in XQuery: string()

string string(object?)

Rules:

A node-set is converted to a string by returning the string-value of the node in the node-set that is first in document order. If the node-set is empty, an empty string is returned.

A number is converted to a string as follows

NaN is converted to the string NaN

positive zero is converted to the string 0

negative zero is converted to the string 0

positive infinity is converted to the string Infinity

negative infinity is converted to the string -Infinity

if the number is an integer, the number is represented in decimal form as a Number with no decimal point and no leading zeros, preceded by a minus sign (-) if the number is negative

otherwise, the number is represented in decimal form as a Number including a decimal point with at least one digit before the decimal point and at least one digit after the decimal point, preceded by a minus sign (-) if the number is negative; there must be no leading zeros before the decimal point apart possibly from the one required digit immediately before the decimal point; beyond the one required digit after the decimal point there must be as many, but only as many, more digits as are needed to uniquely distinguish the number from all other IEEE 754 numeric values.

The boolean false value is converted to the string false. The boolean true value is converted to the string true.

An object of a type other than the four basic types is converted to a string in a way that is dependent on that type.

Hope you find this helpful! So, if you liked the content or found it useful and want to help me write more, you can buy (or help buy) my son a Star Wars Lego!

Author: Sandro Pereira

Sandro Pereira lives in Portugal and works as a consultant at DevScope. In the past years, he has been working on implementing Integration scenarios both on-premises and cloud for various clients, each with different scenarios from a technical point of view, size, and criticality, using Microsoft Azure, Microsoft BizTalk Server and different technologies like AS2, EDI, RosettaNet, SAP, TIBCO etc.

He is a regular blogger, international speaker, and technical reviewer of several BizTalk books all focused on Integration. He is also the author of the book “BizTalk Mapping Patterns & Best Practices”. He has been awarded MVP since 2011 for his contributions to the integration community.
View all posts by Sandro Pereira

Unfortunately, no Logic App connector can make the bridge to RabbitMQ, which makes this integration challenge a little bit more complicated. However, we have the ability to create an Azure Function by using the RabbitMQ trigger for Azure Functions to overpass this limitation.

And we saw and explained in our last blog post that Azure Functions integrates with RabbitMQ via triggers and bindings. The Azure Functions RabbitMQ extension allows you to send and receive messages using the RabbitMQ API with Functions.

The purpose of this video is to explain how you create a POC that allows you to receive a message in a RabbitMQ queue, and that event triggers the Azure Function that then will route the message to a Logic App.

This was a real problem presented by a client during one of our Logic Apps training courses, where they have RabbitMQ on-premises, and they did want to pull messages from a queue into a Logic App Consumption to integrate them with other systems.

Hope you find this helpful! So, if you liked the content or found it useful and want to help me write more content, you can buy (or help buy) my son a Star Wars Lego!

Big thanks to my team member Luís Rigueira for creating this video.

Author: Sandro Pereira

Sandro Pereira lives in Portugal and works as a consultant at DevScope. In the past years, he has been working on implementing Integration scenarios both on-premises and cloud for various clients, each with different scenarios from a technical point of view, size, and criticality, using Microsoft Azure, Microsoft BizTalk Server and different technologies like AS2, EDI, RosettaNet, SAP, TIBCO etc.

He is a regular blogger, international speaker, and technical reviewer of several BizTalk books all focused on Integration. He is also the author of the book “BizTalk Mapping Patterns & Best Practices”. He has been awarded MVP since 2011 for his contributions to the integration community.
View all posts by Sandro Pereira

Function category Category descriptionFunctions in categoryCollection

Used to perform a variety of operations over collections, such as cumulative sum, short, or get distinct values.

Average, Count, Direct Access, Distinct Values, Filter, Index, Join, Maximum, Minimum, Reverse, Sort, Sub Sequence, Sum
Conversion

Used to convert values to specific times.

To DateTime, To integer, To number, To string
Date and TimeUsed to perform a variety of operations over Dates, such as retrieving the current date and time or adding dates.
Add days, Add DayTime to Date, Add DayTime to DateTime, Add DayTime to Time, Add YearMonth to DateTime, Adjust Date, Adjust DateTime, Adjust Time, Current date. Current DateTime value, Current time, DateTime, Day from DAte, Day from DateTime, Equal Date, Equal DateTime, Equal Day, Equal Month, Equal MonthDay, Equal Time, Equal Year, Equal YearMonth, Greater Date, Greater DateTime, Greater Time, Hours from DateTime, Hours from Time, Less Date, Less DateTime, Less Time, Minutes from DateTime, Minutes from Time, Month from Date, Month from DateTime, Seconds from DateTime, Seconds from Time, Subtract Dates, Subtract DateTimes, Subtract DateTime from Date, Subtract DateTime from DateTime, Subtract DateTime from Time, Subtract Times, Subtract YearMonth from Date, Subtract YearMonth from DateTime, Time zone from Date, Time zone from DateTime, Time zone from Time, Year from Date, Year from DateTime.
Logical comparisonUsed to perform a variety of logical operations, such as greater than and logical existence.
Equal, Exists, Greater, Greater or equal, if, if else, Is date, Is DateTime, Is nil, Is null, Is number, Is string, Less, Less or equal, Logical AND, Logical NOT, Logical OR, Not equal
MathematicalUsed to perform a variety of mathematical and scientific operations, such as addition and multiplication.
Absolute, Add, Arctangent, Ceiling, Cosine, Divide, Exponential , Exponential (base 10), Floor, Integre divide, Log, Log (base 10), Modulo, Multiply, Power, Round, Sine, Square root, Subtract, Tangent
String

Used to perform a variety of string functions, such as trimming and concatenation.

Codepoints to string, Concat, Contains, Ends with, Length, Lowercase, Name, Regular expression matches, Regular expression replace, Replace, Start with, String to codepoints, Substring, Substring after, Substring before, Trim, Trim left, Trim right, Uppercase
Utility

Used to perform a variety of additional and distinct operations that don’t fit in the above Categories, such as stopping a transformation and returning the specified error code and description or format a number or a date.

Copy, Error, Format date, Format DateTime value, Format number, Format time

I have been testing Data Mapper for almost maybe 4 months since the first private previews. Still, I have usually tried the Data Mapper capabilities and not the interaction between Logic Apps Standard workflow and the Data Mapper. Now that I’m preparing and finalizing my session for the Azure Logic Apps Community Day 2023, I’m finding these little headaches in trying to put these pieces working together. You also need to be aware that this behavior and experience may change in the future since DaTa Mapper is still in preview.

So, while I was trying to call a transformation created by the new Data Mapper, in this case, a JSON to JSON transformation, running locally in my machine, I was always getting this really annoying and non-sense error since it doesn’t provide any real and valuable help or insight on the issue we are facing:

undefined. undefined

Sometimes I think the Microsoft developer team likes that I write all these Errors and Warnings, Causes and Solutions blog posts, or they are just teasing us.

I was surprised to see this error since I just finished developing my map, and I had successfully tested it on the Data Mapper editor.

And that you can see in action in this video of Kent Weare:

Solution

For the map to run successfully in runtime, within your local.settings.json file in your logic apps standard project, ensure you have the following property configuration:

FUNCTIONS_WORKER_RUNTIME property set to dotnet-isolated.

And add the AzureWebJobsFeatureFlags property with the value: EnableMultiLanguageWorker

Hope you find this helpful! So, if you liked the content or found it helpful and want to help me write more content, you can buy (or help buy) my son a Star Wars Lego!

Author: Sandro Pereira

Sandro Pereira lives in Portugal and works as a consultant at DevScope. In the past years, he has been working on implementing Integration scenarios both on-premises and cloud for various clients, each with different scenarios from a technical point of view, size, and criticality, using Microsoft Azure, Microsoft BizTalk Server and different technologies like AS2, EDI, RosettaNet, SAP, TIBCO etc.

He is a regular blogger, international speaker, and technical reviewer of several BizTalk books all focused on Integration. He is also the author of the book “BizTalk Mapping Patterns & Best Practices”. He has been awarded MVP since 2011 for his contributions to the integration community.
View all posts by Sandro Pereira

I have been developing Logic App Standard for a long time and never had an issue running them locally, as far as I remember, until a few months ago. I never pay too much attention because I was not running them locally, and I didn’t block my ability to develop my solutions or workflows.

However, this week, while developing my demos for the Azure Logic Apps Community Day 2023 event, I had the need to test them locally, and every time I try to run them locally by either:

Start Debugging

Or Run Without Debugging

I was getting the following error:

Failed to find “func host start” task.

Cause

To be honest, I don’t know because I had all the pre-requirements installed, but I guess, and this is just me guessing, that some Azure Function extension update broke some configuration between these to extensions.

Solution

I know that you probably will not like it… but after spending a few hours, I give up and when to a drastic approach – this one – that solved the problem.

To solve this issue, you need to:

Uninstall all Azure Functions extension dependencies.

In my case, the Azure Logic Apps – Data Mapper and Azure Logic Apps (Standard) extensions

Uninstall the Azure Functions extension.

Restart Visual Studio Code

Install all the extensions again, in my case:

Azure Function

Azure Logic Apps (Standard)

Azure Logic Apps – Data Mapper

Just to be in a safe state, restart Visual Studio Code again.

After that I was able to run my workflow locally without any issue.

Hope you find this helpful! So, if you liked the content or found it helpful and want to help me write more content, you can buy (or help buy) my son a Star Wars Lego!

Author: Sandro Pereira

Sandro Pereira lives in Portugal and works as a consultant at DevScope. In the past years, he has been working on implementing Integration scenarios both on-premises and cloud for various clients, each with different scenarios from a technical point of view, size, and criticality, using Microsoft Azure, Microsoft BizTalk Server and different technologies like AS2, EDI, RosettaNet, SAP, TIBCO etc.

He is a regular blogger, international speaker, and technical reviewer of several BizTalk books all focused on Integration. He is also the author of the book “BizTalk Mapping Patterns & Best Practices”. He has been awarded MVP since 2011 for his contributions to the integration community.
View all posts by Sandro Pereira

An Integration Account allows you to build Logic Apps with enterprise B2B capabilities by adding various necessary artifacts. It serves as a central repository for managing various integration assets such as schemas, maps, certificates, and trading partner agreements.

While nowadays, Logic App Standard natively supports Schemas and maps (without the need for an Integration Account), and there is a new transformation editor called Data Mapper (still in preview). Logic App Consumption still requires us to use the Integration Account and still uses the “old kind of related BizTalk Server Mapper”.

Pre-requirements

So, for us to create, in our developer environment, Schemas and Maps for Logic App Consumption to be used inside an Integration Account we need to install Azure Logic Apps Enterprise Integration Toolsextension for Visual Studio 2019 – unfortunately, there is no support for recent versions of Visual Studio. To do that, we need to:

Download and Install the extension from the Visual Studio Marketplace:

Or install it directly on Visual Studio by:

Open Visual Studio 2019, and on the Extensions menu, select the option Manage Extensions.

Search for Logic App, and then from the list, select todownload and install the Azure Logic Apps Enterprise Integration Tools.

You will probably need to restart Visual Studio.

Create an Integration Account Project

Now that we have installed everything that we need to create a new Integration Account Project, we need to:

Open Visual Studio 2019 and on the What would you like to do? window select the Create a new project option.

On the Create a new project window, search for Integration Account, and from the list below, select the Integration Account template, then click Next.

On the Configure your new project window, do the following configurations and then click Create:

On the Project name property, set a proper name for your project.

On the Location property, set the path where you want to create the project.

On the Solution name property, set a proper name for your project.

Note that a solution is a container for one or more projects in Visual Studio.

After that, a new Integration Account project is created where you can create your Schemas, Flat File Schemas, and Maps. To do that, you just need to:

Right-click on the project name and then select the option Add > New Item…

On the Add New Item window, on the left tree, select the option Logic Apps, and all the possible artifacts for you to create will be present.

Select the type.

Give it a proper name.

And click Add.

Hope you find this helpful! So, if you liked the content or found it helpful and want to help me write more content, you can buy (or help buy) my son a Star Wars Lego!

Some of the various artifacts that can be added with an integration account are: Schemas: These are standard . xsd files containing the definition of an XML message

Author: Sandro Pereira

Sandro Pereira lives in Portugal and works as a consultant at DevScope. In the past years, he has been working on implementing Integration scenarios both on-premises and cloud for various clients, each with different scenarios from a technical point of view, size, and criticality, using Microsoft Azure, Microsoft BizTalk Server and different technologies like AS2, EDI, RosettaNet, SAP, TIBCO etc.

He is a regular blogger, international speaker, and technical reviewer of several BizTalk books all focused on Integration. He is also the author of the book “BizTalk Mapping Patterns & Best Practices”. He has been awarded MVP since 2011 for his contributions to the integration community.
View all posts by Sandro Pereira

With INTEGRATE 2023 London concluded, time to shift gears to the next big event on cloud integration: Azure Logic Apps Community Day 2023, sometimes called LogicAppsAviators Community Day, which will take place on Thursday, June 22nd at 9 AM (Pacific) or 5 PM (UTC). The event is free and will be streamed on YouTube/Twitch, so be sure to subscribe to the Azure Developers YouTube to stay up to date.

Azure Logic Apps Community Day 2023will be the must-attend event for anyone who wants to learn more about Logic Apps and how it can help to solve real-life integration problems. It will be a full day of learning from the basics of getting started to deep dives into advanced automation with Logic Apps presented by the Logic Apps product group, Microsoft MVPs, and expert community members. In the end, will be a Round Table Discussion – Ask Me Anything with the Product Group and Community – this will be your opportunity to make “hard” questions.

I will have the pleasure of delivering a session about the new Data Mapper at this event and also be part of the panel on the Round Table Discussion!

About my session

Session Name: A walk in the park with the new Logic App Data Mapper

Abstract: In this session, we will present the new Data Mapper experience for Logic Apps Standard and how we can apply XML to XML transformations or XML to JSON transformations using a visual designer. Here, we will also address how to implement well-known mapping patterns like direct translation, Data translation, content enricher, or aggregator patterns alongside many others.

Hope you find this helpful! So, if you liked the content or found it helpful and want to help me write more content, you can buy (or help buy) my son a Star Wars Lego!

Author: Sandro Pereira

Sandro Pereira lives in Portugal and works as a consultant at DevScope. In the past years, he has been working on implementing Integration scenarios both on-premises and cloud for various clients, each with different scenarios from a technical point of view, size, and criticality, using Microsoft Azure, Microsoft BizTalk Server and different technologies like AS2, EDI, RosettaNet, SAP, TIBCO etc.

He is a regular blogger, international speaker, and technical reviewer of several BizTalk books all focused on Integration. He is also the author of the book “BizTalk Mapping Patterns & Best Practices”. He has been awarded MVP since 2011 for his contributions to the integration community.
View all posts by Sandro Pereira