►
From YouTube: Elsa Workflows Community Meeting 1 ( 2022-03-22 )
Description
This is the recording of the first Elsa Workflows Community meeting ever!
Unfortunately the audio of the other participants weren't recorded, so it's just me talking :D
In this video, we talk about:
- The weekly meeting itself
- Steering Committee Elections / OS Governance
- Status
- 2.6 released
- 2.7
- 3.0
- Demos
- Redacting sensitive information
- Retention policy
- Suggestion: make the "hard delete" replaceable
A
Great
that
you
guys
could
join
this
is
the
the
first
weekly
meeting,
hopefully
of
many
more
weeks
of
elsa
workflows
and,
as
I
just
said,
I
think
it
might
be
a
nice
way
for
the
community
to
see
what
the
status
is.
What
we're
thinking
about,
also
a
nice
opportunity
to
give
some
demos
that
that
I
can
do
or
anyone
else
from
the
community
really
any
topics
that
people
might
want
to
race.
We
can
discuss
those
things.
Speaking
of
topics,
I
have
a
bunch
of
them.
First
of
all,
this
weekly
meeting.
A
This
is
the
first
meeting
ever
we're
recording
this.
Hopefully
it
will
contain
some
useful
content
for
folks
to
to
watch
later,
especially
maybe
when
it
comes
to
decisions
we
make
or
topics
we're
thinking
about
design
decisions,
but
also
demos,
as
I
mentioned,
of
course,
the
steering
committee
elections
I
announced
yesterday
and
well,
what's
the
point
of
a
steering
committee.
As
many
of
you
know,
I've
been
doing
this
project
largely
largely
by
myself,
and
then
I
enjoy
doing
that,
and
I
will
keep
doing
that,
but
the
community
is
growing.
A
Pretty
big
elsa
has
become
an
important
component
for
many
applications.
Already
so
I
figured
it
would
be
good
to
to
have
a
an
official
committee
that
that
can
manage
the
project
and
the
community
and
also
as
a
way
to
bounce
off
ideas
and
well
govern
the
project
instead
of
it
being
just
me.
It
would
be
good
to
have,
for
example,
could
be
anything
really
anything
related
to
the
elsa
project
and,
of
course,
it's
all
volunt
voluntarily.
So
it's
not
like
you're,
though
those
people
are
commit,
are
obligated
to
do
anything.
A
It's
I
think
it
might
be.
It's
a
nice
title.
It
also
gives
you
a
voice
in
in
the
potential
directions
of
the
project.
So
it's
it
could
be
interesting
for
people
who
use
elsa
actively
and
have
a
stake
in
the
project.
If
you
will
to
give
them
a
vote
and
obviously
we
will.
We
always
listen
to
what
what
the
community's
sentiment
is.
A
So
if,
if,
if
we
see
that
certain
features
are
missing
or
there's,
there's
a
big
demand
for
documentation,
which
I
know
there
is
we,
of
course
we
respond
to
those
things
yeah.
Some
of
these
topics
are
more
easily
discussed
amongst
a
committee.
The
steering
committee
is
one
form
of
trying
to
govern
this
project.
A
I've
been
reading
and
listening
a
lot
about
the
house,
so
that's
decentralized,
autonomous
organizations
as
a
as
another
vehicle
to
govern
something.
This
might
be
interesting
to
explore
later.
There's
there's
a
lot
of
investigation
to
do
before.
We
try
such
a
thing,
but
I
think
it's
an
interesting
notion
as
well
all
right.
So,
let's
first
go
over
the
the
current
status,
as
some
of
you
know,
2.6
was
released
yesterday
or
the
day
before
yesterday
two
days
ago,
and
yes,
all
bunch
of
things
are
new.
A
Some
small
features
like
this
javascript
function,
but
the
biggest
change
for
this
one
is
has
to
do
with
stability,
especially
regarding
the
azure
service
bus
activities.
I
know
of
a
customer,
they
are
using
this
heavily
and
they
were
seeing
a
lot
of
issues
with
2.5.
Thanks
to
I
believe
it
was
jay
for.
Forgive
me
if
I'm
wrong
jeremy,
that
that
was
crucial.
The
the
findings.
You
did
so
that
I'm
very
grateful
for
that.
After
that,
that
was
fixed.
The
issues
disappeared
immediately.
A
So
that
was
a
big
big
issue
for
this.
For
this
customer
yeah
and
speaking
of
which,
of
course,
this
is
also
a
call
to
to
folks
who
are
interested
in
becoming
a
steering
committee,
a
member
to
announce
yourself
as
a
candidate
for
the
election
that
we
then
start
two
weeks
from
now
give
or
take.
So
that
would
be.
That
would
be
really
nice
and
we
still
have
to
discuss
the
election
process
itself.
A
What
it
would
look
like,
for
example,
would
people
get
five
votes
to
distribute
amongst
the
candidates
and
to
be
clear,
I'm
I'm
thinking
of
having
a
maximum
of
five
members
in
the
committee
and
then
each
voter
could
spend
one
of
their
fire
or
their
five
votes
on
one
candidate
or
one
of
each
or
or
should
everyone
get
one
vote?
That's
something
we
can
discuss
in
a
week
or
two,
but
it
will
be
good
to
give
it
some
thought
yeah
so
back
to
the
2.6
release.
A
So,
as
I
said,
that's
that's
the
major
improvement.
Everything
else
is
just
whatever
got
in
with
the
2.6
release,
and
I
I
think
we
should
try
to
release
regularly
and
then
just
see
whatever
gets
in,
gets
in
and
then,
if
something
doesn't
make
a
release,
probably
going
to
make
it
the
next
release
and
then
try
to
maybe
release.
I
don't
know
every
month
or
maybe
every
two
months.
We
we
have
to
see
what
makes
sense
and
what's
realistic
but
having
a
predictable
release.
A
Cadence
might
might
be
good
for
for
for
us
in
the
community
to
to
rely
on
increasingly
so
this
was
another
important
fix
for
some
scenarios
if
you
use
nested,
forks
and
joints
that
didn't
work,
but
now
it
does
so
that
was
that
was
a
good
fix,
so
yeah
I
was
pointing
here
and
here
everywhere,
so
the
this
issue
by
the
way,
of
course.
Oh,
this
is
a
release
notes.
A
I
have
issues
hint
at
the
top
here
about
weekly
community
meeting
that
we're
having
right
now
this
one
and
the
steering
committee
elections.
That's
this
one!
So
if
you,
if
you
want
to
read
about
the
rules
proposed
rules,
I
just
made
this
up.
As
I
went.
If
you
have
any
suggestions,
feedback
or
other
thoughts,
please
share
them
here,
and
then
we
can
take
them
into
account
all
right.
A
So
now,
with
2.6
out
of
the
way
2.7
I
I
would
like
to
release,
I
think
I
said
a
milestone
here
april
30,
so
so
trying
to
release
every
month.
I
will
see
if
that's
practical
or
not,
but
it's
what
I'm
gonna
try
right
now.
It
contains
a
bunch
of
stuff
that
that
some
of
it
has
been
moved
from
2.6
to
this
milestone.
Others
are
added
to
this
directly.
A
We
might
use
this
meeting
as
as
a
grooming
session,
so
we
go
over
these
issues
and
then
prioritize
them,
move
them
out
to
a
different
milestone
or
back
to
the
backlog.
If
we
think
it's
not
important
enough
enough
compared
to
other
items
well,
we
will
see.
We
could
also
have
a
separate
triage
meeting
because
generally
it
can
be
become
a
little
bit
boring
to
to
watch
at
least
look
at
issues
and
then
discuss
them
unless
you're
a
stakeholder
of
that
issue,
then
it's
interesting
so
yeah
for
2.7.
A
I
do
know
that
there's
a
bunch
of
ers
and
one
is
a
very
big
one.
It
has
to
do
with
multi-tenancy
and
this
pr
created
by
constantine.
It
did
a
lot
of
work
to
to
enable
multi-tenant
configurations.
So
here
you
would
have
not
multi-tenancy
at
the
service
collection
level.
I
I
think,
but
but
at
the
very
least,
every
tenant
will
have
its
own
configuration.
A
So
that
means
you
could
have
a
single
deployment
but
pointing
to
different
databases
or
the
same
database
actually
different
databases.
This
does
not
support
the
same
database,
but
with
differentiating
table
prefixes,
for
example
like
orchard
core.
Does
that
that's
not
here,
but
it
serves
their
purpose?
I
am
considering
merging
this
in,
but
I
want
to
find
a
way
to
try
it
first,
not
just
me,
but
also
maybe
others.
A
So
maybe
what
I'm
going
to
do
is
I'm
going
to
merge
it
into
master
so
that
it
gets
deployed
to
my
get
multi-tenancy
by
the
way
is
optional,
it's
not
going
to
be
enabled
by
default.
So
in
theory
nobody
should
be
bothered
by
it.
But
if
you
want
to
try
it
out,
that
would
be
good
and
try
and
get
a
gather
some
feedback.
A
As
you
know,
in
lc2
we're
using
a
fluent
interface,
let's
see
if
I
can
find
an
example
yeah,
for
example
here
so
here
we
have
a
user
registration
workflow,
a
very
simple
one
and
it
uses
extension
methods
to
create
and
then
link
activities
to
each
other.
So
this
is
in
lsr2.
The
the
type
of
workflow
is
always
a
that
of
a
flow
chart
and
in
the
way,
flowchart
works.
A
You
have
nodes
in
the
in
the
diagram
and
they're
connected
through
connections,
and
this
is
what
the
fluent
api
allows
you
to
do
and
for
elsa
3
things
are
a
little
bit
different.
So
the
way
it
works
in
lsat
3
is
there's
no
fluent
api.
Instead,
you
are
directly
instantiating
the
activities
as
if
they
were
little
lego
blocks
to
build
a
house.
That's
what
you
do
in
elsa
3
when
using
the
the
programmatic
well
api.
If
you
will
and
I'll
find
an
example
for
that.
So
here
we
have
an
example.
This
is
elsa
free
syntax.
A
You
still
have
a
workflow
builder,
so
you
implement
the
workflow
using
this
interface.
You
get
a
build
method
that
you
implement
to
actually
build
out
your
graph
and
then
the
big
difference
here
is
that
your
workflow
can
only
have
one
activity.
It's
called
the
root,
so
it's
the
root
of
your
diagram.
Basically,
and
if
you
wanted
to
have
multiple
activities
you
can
use
a
in
this
example,
a
sequence
and
a
sequence
is
just
a
sequence
of
steps.
So
it's
like
a
list
of
activities
and
they
execute
one
after
the
other.
A
So
in
this
example,
we
are
setting
the
activities
list
of
the
sequence
to
an
instance
of
an
http
endpoint,
then
an
if
construct
or
an
effectivity,
and
then
a
write,
http
response.
So
it
goes
from
this
one
to
this
one
to
this
one.
So
there's,
as
you
can
see,
there's
no
connections,
it's
just
a
sequence.
That's
just
one
style
of
a
diagram.
There's
of
course,
also
a
different
one
called
the
float
chart
diagram
in
the
flowchart
diagram
itself
has
a
list
of
children
and
it
has
connections
between
those
children.
A
Clearly
inspired
on
the
on
the
windows,
workflow
foundation,
api,
it's
what
I
tried
to
do
for
elsa
2
when
I
started
it,
but
I
couldn't
find
a
good
way
between
the
ability
to
just
connect
nodes
using
the
connection
object
which
we,
what
we
have
for
the
flowchart.
So
here
it
has
a
list
of
connections
and
and
combine
it
with
things
like
what
we
have
here
with,
if
so
here,
if
it
has
a
then
property
and
an
else
property
and
the
type
of
these
properties
are
activity.
A
So
that's
that's
just
a
different
way
of
connecting
to
nodes
right
so
but
for
elsa
3.
I
think
I
found
a
nice
solution
to
that,
where
you
are
explicit
about
the
type
of
diagram,
so
here
this
is
a
sequence.
It
doesn't
have
a
notion
of
connections,
but
a
float
chart,
of
course,
totally
can
have
a
concept
of
connections
and
yeah
and
and
of
course
the
challenge
is.
A
How
do
you
deal
with
that
in
the
designer,
speaking
of
which
let
me
load
the
designer,
so
while
that
loads,
I
actually
want
to
show
another
change
in
ls3,
which
has
to
do
with
the
way
you
deal
with
variables,
for
example.
So
here
again
we
have
a
simple
workflow
here:
I'm
defining
a
workflow
variable,
so
it's
just
you're,
just
a
local
variable
to
this
method.
A
I
assign
it
to
the
variables
collection
so
that
it's
in
the
scope
of
this
sequence-
and
this
is
important
variables
and
lc3-
have
their
own
scope
and
different
container
activities,
have
their
own
scope
of
variables
and
what's
nice
about
having
this
as
a
c-sharp
variable
in
this
way,
is
that
you
can
reference
it
directly.
So
here
I'm
running
a
bit
of
javascript
activity
that
evaluates
one
plus
one
and
it
stores
the
output
in
this
variable.
So
the
output
in,
in
fact
this
this
is
an
activity
that
this
is
a
wrong
example.
A
This
from
javascript
activity
has
an
output
a
result,
and
that
result
is
then
assigned
to
this
variable.
And
now
this
variable
carries
a
reference
to
this
this
result
and
then
you
can
use
it,
for
example
here
so
here
I'm
writing
out
whatever
the
output
was
of
the
run,
javascript
activity
by
saying
variable,
dot
get,
and
then
it
requires
the
the
context.
It's
it's
like
the
activity
execution
context
from
elsa
too,
but
here's
called
the
expression
excuse
execution
context.
A
So
it's
a
it's
a
bit
of
an
abstraction
so
that
it
can
also
be
used
outside
of
the
context
of
workflow
execution,
which
is
important
for
determining
determining
the
the
bookmarks
or
the
triggers
of
the
workflow.
So
some
aspects
are
similar.
Some
others
are
very
different,
but
I
I
will
try
and
document
these
things,
of
course,
before
this
is
actually
released
at
this
point.
It's
it's
a
lot.
There's
a
lot
of
changes
going
on.
A
A
So
let's
make
this
a
an
infinite
loop
and
it
has
a
an
it
iterate
or
a
body
that
executes
during
each
iteration,
and
this
could
be,
let's
say,
sequence
and
the
sequence
can
have
variables
and
then
this
variable
could
be
well.
Let's
declare
it
here,
but
to
be
clear,
this
is
a
c
sharp
variable,
the
stamp
thing,
but
it's
of
type
variable
and
that's
a
workflow
variable,
and
it's
declared
here
the
reason
I'm
I'm
assigning
it
to
a
local
variable
is
so
that
I
can
reference
it
from
code.
A
But
when
the
workflow
executes
it
only
exists
in
this
sequence.
Now,
while
this
every
time
this
iterates,
this
variable
will
be
reinitialized,
so
it
will
lose
its
its
value,
and
this
is
important
for
scenarios
where,
where
you
want
to
actually
lose
this
information,
because
maybe
if
you're
you're
maintaining
an
index
of
something
and
then
that
should
only
keep
incrementing
within
the
loop.
A
But
if
the
at
some
point
the
while
loop
exits
and
it
continues
on
to
the
next
activity
and
then
some
activity
somehow
loops
back
to
this
wow,
you
don't
want
the
variable
to
begin
with,
for
example,
the
value
of
10.
If
you
had
10
iterations,
and
then
you
had
logic
depending
on
that,
so
it's
it's
a
little
bit
similar
to
why
you
would
want
you,
don't
want
global
variables
in
a
c-sharp
program
or
in
any
application.
A
Okay,
I
have
a
variable
of
this
variable,
the
the
storage
for
this
variable-
it's
not
visible
from
here,
but
it
exists
in
in
the
activity
execution
context
that
get
created
as
activities
start
to
execute
it's
two
separate
worlds,
so
to
speak,
seize
your
world
in
the
workflow
world.
From
the
c-sharp
point
of
view,
you
are
building
your
diagram,
but
once
it
executes,
you
need
to
try
and
shift
focus
from
this
stamp
variable
to
exist
only
within
this
scope
within
the
sequence,
scope
and
then,
of
course,
here
this
one
here.
A
But
let's,
let's
now
create
a
set
of
steps
here
I
say,
for
example,
right
line,
and
then
I
want
to
maybe
print
the
current
value.
So,
as
you
can
see,
the
value
can
only
be
accessed.
The
variable
can
only
be
accessed
by
having
context,
and
this
is
important,
because
this
context
is
what
actually
stores
the
the
variables
content
or
the
value
within
a
thing
called
a
register.
A
So
it's
like
computer
memory,
there's
a
concept
of
an
hierarchical
set
of
registers
to
to
implement
this
scoping
of
of
data
yeah
and,
of
course,
being
able
to
code
it
like
this.
It's
it's
also.
What
you
could
do
is
is
create
composite
activities
easily,
but
also
create
functions
that
build
up
parts
of
your
workflow.
In
case
you
have
a
more
complicated
workflow.
A
It's
it's
easier
to
do
than
compared
to
ls2,
especially
because
there,
in
order
to
make
the
syntax
look
nice,
you
need
to
write
a
lot
of
extension
methods
which
require
a
lot
of
maintenance
but,
more
importantly,
the
flow
and
the
in
the
hierarchy.
It's
more
natural
in
ls3
and
what
I
mean
by
that
is,
for
example,
in
lsat
2.
We
have
a
notion
of
composite
activities
but
to
implement
that
lots
of
well
tricks
had
to
be
pulled
out
of
my
sleeve
to
to
make
that
work.
A
But
then
there's
also
some
caveats
there
that
make
it
a
little
bit
unnatural
and
also
three
there's
none
of
that.
It's
just
natively.
You
can
create
a
new
composite
activity
in
a
composite.
Is
it's
like
a
workflow?
It
just
has
a
root
activity
that
can
be
anything
so
in
this
example,
could
be
a
sequence.
It
could
be
a
flowchart,
it
could
be
just
a
right
line,
activity
doesn't
matter
and
it
will
be
even
more
useful
when
you
use
the
designer
and
the
designer
allowing
you
to
create
a
composite
activity
using
the
designer.
A
So
that
could
be,
let's
say,
a
sequence
that
has
a
series
of
steps
that
you
want
to
use.
So
now
you
have
a
composite
activity
that
you
can
reuse
in
other
workflows,
increasing
your
productivity.
Hopefully,
for
example-
let's
say
in
this-
while
let's
say
I
have
here
sequence
with
activities
and
now
here
I
want
to
say,
let's
run
a
little
flow
chart
and
then
you
need
to
define
the
activities.
A
So
this
is
a
simple
array
of
activities
that
would
exist
within
your
flow
and
you
need
to
define
the
connections
now.
For
this
it
is
straightforward
to
setup,
but
could
be
enhanced
using
a
affluent
api,
maybe
to
build
and
link
activities
similar
to
the
way
it's
done
in
lc2.
That
could
be
added
later,
if,
if
we
think
it's
useful
yeah,
so
this
is
this
like
that,
of
course,
you
can
have
you
can
define
a
activity
so
that
you
can
just
use
the
this
composite.
A
So
here
what
I'm
doing
I'm
creating
new
flowchart,
I
could
also
say
do
a
new
composite
that
has
a
root,
which
then
has
this
flow
chart
yeah.
You
may
wonder:
what's
the
point
of
that
more
useful
might
be
to
have
a
custom
activity
that
is
a
composite
from,
and
then
you
use
it's
constructed
to
define
its
root.
Then
you
can
reuse
it
easily
in
in
in
your
workflows.
So
let
me
see
if
I
can
undo
my
errors
and
start
this
project
here.
A
It
could
be
that
it's
very
slow
because
of
the
screen
recording
and
the
sharing-
I
don't
know
oh-
might
be
trying
to
connect
to
a
non-running
sql
server.
I
know
what
this
is
it's
well.
This
is
a
bug
I'm
just
discovering
now,
but
I
also
know
what
to
cause
it
all
right.
So
this
is
an
initial
look
for
the
elsa
free
designer,
very
basic,
bare
bones.
For
now,
my
main
focus
is
to
make
it
functional
and
then
later
maybe
look
at
the
aesthetics.
A
What
I
am
trying
for
this
iteration
is
for
the
designer
to
be
embeddable
and
also
have
the
basic
necessities
that
you
would
need,
for
example,
have
a
workflow
definition
browser
instead
of
having
it
as
a
separate
view.
I
want
it
to
be
part
of
the
this
one
component
to
keep
things
simple,
and
it
would
allow
other
developers,
of
course,
to
have
there's
always
the
option
of
creating
your
own
dashboard.
A
But
what
I'm
planning
on
doing
is
to
start
a
new
project,
a
dashboard
project
that
may
or
may
not
embed
this
designer,
if
it
initially
it
will.
Ultimately,
I
might
migrate
this
to
using
laser
as
the
technology
to
implement
this
design,
but
also
to
have
a
modular
application
framework
for
the
for
the
dashboard
so
that
you
can
do
things
like
creating
custom
modules
that
are
specific
to
your
own
application
and
install
existing
modules
from
the
gallery
from
from
nougat
that
add
features
like
forms
or
other
functionality,
but
these
are
still
just
thoughts,
nothing
really
concrete.
A
Yet
so,
if
anyone
has
any
thoughts
on
that,
please
do
share.
But
this
is
the
current
status.
You
can
pick
and
choose
your
workflow,
there's
and
and
zoom.
So
let
me
add
some
activities,
so
you
can
see
it
in
action
boom.
Let
me
move
it
here:
zoom
out
zoom
in
there's
a
properties
pane
on
the
right
hand,
side
so
allow
you
to
quickly
make
changes
to
these
activities,
properties,
there's
no
common
properties,
yet
you
can
publish
if
it
works.
Nope
I
broke
it,
but
you
yeah,
you
get
the
idea.
A
I
know
of
a
few
bugs
that
make
it
not
work,
but
I'm
working
on
fixing
that
hopefully
around
may
there
will
be
an
initial
release
of
our
preview
release
of
ls3
just
to
to
give
it
a
spin.
The
fluent
api
build
workflows
that
syntax
is
not
automatically
going
to
work
for
the
for
the
new
syntax.
I
haven't
given
it
that
much
thought
to
see.
A
If
that
could
be
ported
as
is-
and
I
don't
want
to
say
it's
in-
it's
not
possible
because
maybe
it
is
but
I'm
I'm
not
sure
what
the
amount
of
effort
would
be
involved
in
allowing
for
that
and
if
it's
even
possible,
it
will
be
interesting
to
to
try
out
to
see
what
it
would
take
to
take
it
as
is
and
fit
it
into
the
lz3
engine,
because
the
elsa
3
engine
is
very
versatile.
It
can't
support
any
kind
of
workflow
or
activity
type.
A
I
am
considering
an
experiment
to
try
and
basically
take
an
lsat
2
workflow
that
you
would
have
designed
through
the
designer
and
execute
it
through
the
version
3
engine,
but
this
also
depends
on
bandwidth
and
other
priorities
backwards.
Compatible
compatibility,
isn't
important.
Yeah.
We
have
to
see
what
what
what
the
bandwidth
looks
like.
So
when
you
talk
about
workflow
definitions
designed
by
the
designer,
we
can
totally
imagine
having
a
converter.
A
So
you
take
the
source
work
for
definition,
transform
them
into
an
elsa
3
format,
because
then,
of
course,
it's
easy
to
also
make
changes
to
those
workflows
if
we
weren't,
if
we
wouldn't
do
that,
that
means
that
the
designer
too
should
have
some
sort
of
compatibility
with
the
elsa
tool
format,
and
that
might
be
a
lot
of
work,
and
I
think
at
this
point
we're
a
little
bit
too
small
to
to
allow
for
that
unless
there
wasn't
anything
else
to
do
right,
but
there's
a
there's.
A
lot
of
other
missing
features
to
do
as
well.
A
All
right,
we
got
a
little
over
50
minutes
left.
I
wanted
to
show
two
new
features
of
2.6
or
actually
retention
policy
isn't
new,
but
I
figured
might
as
well
take
this
opportunity
to
show
what
that
looks
like
in
ls2,
because
it's
not
documented
yet.
So
let
me
talk
a
little
bit
about
what
is
retention,
the
retention
policy.
In
this
context,
it's
just
about
being
able
to
delete
your
workflow
instances
automatically,
but
of
course
not
just
any
workflow
instance.
A
You
should
be
able
to
control
the
aids
of
the
workflow
instances
and
under
which,
what's
conditions,
they
should
be
eligible
to
be
deleted.
Active
workflows,
you
probably
don't
want
to
delete,
but
maybe
workflow
engines
that
have
completed
60
days
ago.
Maybe
you
want
to
clean
them
up,
because
if
you
don't,
the
database
file
will
grow,
grow
and
grow,
including
it
includes
the
workflow
execution
log
and
workflow
instances
that
have
executed
for
a
long
time.
They
will
have
generated
a
lot
of
execution
log
records.
A
So
you
may
want
to
be
cleaning
that
up
and
using
a
retention
policy
you
can
do
so
automatically
and
with
2.6
there's
now
the
option
to
have
full
control
over
the
conditions
under
which
you
would
like
to
these
instances
to
be
deleted.
Let
me
see
if
I
can
find
the
example.
So
here
you
can
see
it.
There's
the
add
retention
services
function,
that's
added
by
the
retention
module,
which
is
a
separate
package.
If
you
reference
it,
you'll
have
this
method
available
to
you
on
the
elsa
options,
object
and
then
what
you
can
do.
A
You
can
configure
its
options,
which
is
of
type
cleanup
options,
and
here
you
can
specify
things
like
a
sweep
interval.
So
that's
the
the
amount
of
time
to
wait
before
loading
workflow
instances
from
the
database
to
be
deleted.
You
can
specify
a
bet
size
so
that
it's
not
gonna
load
in
thousands
of
workflow
instances,
but
just
100
at
a
time
by
default
and
the
time
to
live.
A
So
that's
the
maximum
age
of
a
workflow
instance
that
it's
allowed
to
exist
before
being
removed
and
then
there's
a
a
pipeline
basically
which
allows
your
application
to
control
if
a
workflow
instance
is
actually
eligible
to
be
deleted
or
not.
Here
I
have
an
example
here
I
add
a
filter
to
this
this
pipeline.
So
I'm
specifying
my
own
pipeline
here
and
here
I'm
saying
add
this
workflow
status
filter,
which
is
implemented
as
follows.
Basically,
well
it
implements
the
get
your
delete
method
and
it
needs
to
return
true
or
false.
A
If
you
return
true,
the
workflow
instance
will
be
deleted.
Otherwise,
it
won't
and
the
pipeline
stops
as
soon
as
it
receives
a
true
as
or
or
false.
Actually,
that's,
I
might
be
confusing
myself.
Let
me
see,
I
should
add
a
xml
comment
here.
So
this
is
the
abstract
class.
It's
invoked
here,
yeah,
so
as
soon
as
it
returns
true
as
soon
as
the
word,
for
instance,
needs
to
be
deleted.
The
pipeline
stops.
A
If
you
return
false,
it
goes
on
to
the
next
filter
and
ultimately,
if
nobody
returned
true,
then
the
workflow
instance
will
not
be
deleted
and
to
be
clear,
it
only
passes
through
the
pipeline
workplaces
that
that's
these
basic
criteria
that
I
talked
about
here.
So
it
needs
to
have
see
that
it's
time
to
live
well,
actually,
that's
it.
So
this
is
the
basic
control.
We
could
enhance
it
further
if
you
think
that's
necessary,
but
that's
what
it
is
right
now.
A
So
you
mean
within
the
four
hours,
because
every
four
hours
it
will
continuously
load
the
next
100
and
you're
saying
well,
if
you
have
maybe,
if
you're
generating
more
than
100-
let's
say
every,
I
don't
know
every
minute
and
then
that's
like
an
extreme
number,
and
this
might
not
be
able
to
keep
up.
If
that's
the
case,
then
you
can
of
course
increase
the
bet,
size
and
decrease
the
sweep
inflow.
But
when,
when
the
sweep
is
taking
place,
it
will
continuously
load,
be
loading
workflow
instances.
So
it's
not
gonna
take
100
every
four
hours.
A
A
So
right
now
the
behavior
is
a
hard
delete,
but
maybe
that
can
be
replaced
with
a
service
or
some
provider
that
or
a
strategy
that
you
control
as
a
as
an
application,
and
then
you
can
totally
choose
to.
Instead
of
deleting
it
migrating
it
to
another
database
or
both
first
copy
it
over
and
then
delete
whatever
makes
sense
for
your
scenario,
but
that's
that's
a
good
idea.
We
can
do
that
yeah
so
here,
currently,
it's
hardcoded
using
a
cleanup
job.
That's
resolved
here,
of
course,
this
cleanup
job.
It
has
this
this
logic,
but
yeah.
A
We
can
have
it
inject
as
a
strategy
that
by
default,
performs
the
heart
but
can
be
easily
replaced.
I
like
that.
So
the
next
thing
is
redacting
sensitive
information
very
important
right
now.
Imagine
if
you
have
an
http
endpoint
on
your
workflow
and
it
receives
user
locks
logins,
for
example,
using
a
username
and
password.
This
information
will
be
stored
in
your
workflow
instance,
and
the
workflow
execution
log
and
through
the
designer
people,
will
be
able
to
see
this
information,
and
that's
not
desirable.
A
So
if
you
have
that
situation,
then
what
you
want
to
do
is
redact
that
that
data
as
it
as
it
gets
displayed
or
as
it
enters
the
system.
Currently
you
can't
redact
as
it
enters
the
system.
It's
just
not
implemented,
but
we
could,
but
what's
more
important,
is
that
it's
not
visible
to
users
of
the
designer
or
and
looking
at
the
workflow
execution
log.
So
what
you
can
do
is
filter
that
out
as
follows.
A
So
here
there's
a
sample
application
called
mask
viii,
and
the
scenario
here
is
is
that
we
have
a
user
registration
workflow
where
the
user
signs
up,
they
post
their
username
and
their
password,
for
example,
and
we
don't
and
we
want
to
filter
it
out,
as
the
workflow
execution
log
gets
displayed
in
the
front
end.
So
to
do
so,
you
need
to
implement
a
filter.
Let
me
see
okay,
so
there's
there's
two
types
of
filters,
so
this
is
the
activity
state
filter
that
is
displayed
in
the
front
end.
Actually
I
should
show
you
all
right.
A
So
let's
say
we
have
a
workflow
called
signup,
exposing
an
endpoint
to
store
a
user.
Let's,
let's
actually
give
that
a
try.
So
I'm
gonna
run
this
hp
request
and
that's
done
so.
If
we
now
look
at
the
workflow
instance,
this
one,
you
can
look
at
this
activity
state
try
to
remember
if
it
was
actually
storing
this
data
in
the
activity
state
or
not.
I
don't
think
that's
the
case
here,
but
in
the
journal
you
would
of
course
see
the
inbound
http
request.
You
saw
it
in
the
activity
state
yeah.
A
So
in
the
journal,
it's
reacted.
Yeah
exactly.
You
may
have
expected
this.
This
complicated
password,
but
it's
redacted
to
implement
this.
You
need
to
it's.
That's
this
one,
and
I
I
got
confused
with
this
hp.
Endpoint
workflow
journal
field
is
what
you
have
to
implement.
The
iworkflow
journal
filter
itself.
You
can
do
it
directly,
but
for
http
endpoints.
A
I
imagine,
there's
probably
some
fields
that
you
always
want
to
be
able
to
process
easily
when
protecting
or
when
redacting
http
requests
such
as
the
the
body,
the
roboty
and
the
headers.
So
this
is
more
of
a
convenience,
a
base
class.
If
you
have
a
scenario
where
you
want
to
redact
inbound
hp
requests
using
http
endpoint,
then
this
is
a
convenient
face
class
and
what
your
it
allows.
A
Your
application
to
do
is
just
say:
I
want
to
process
the
body
and
then
what
do
you
do
you
just
say:
okay,
I
know
I'm
receiving
a
password
field
in
the
body
and
I'll
just
replace
that
value
with
well,
in
this
case
some
asterisks.
The
same
goes
for
the
raw
body
field
of
the
hp
endpoint.
Of
course,
this
requires
some
some
intimate
knowledge
of
the
hp
end
point
over
its
outputs
and
what
it's
storing
actually
in
the
journal,
to
see
that,
let's
take
a
look
at
the
hp
endpoint.
A
So
here
we
know
it's
storing
it,
the
inbound
request.
So
that's
it's
storing
its
8-speed
request
model
and,
of
course,
we
know
that
it
has
a
what
has
the
headers.
It
has
a
body
and
a
raw
body,
and
so
this
is
what
we
want
to
process
when
redacting
then
there's
an
activity,
state
filter
which
does
a
similar
thing
but
for
the
activity
state.
So
if
we
now
click
the
store
user,
we
select
this
one
and
we
look
at
its
state.
A
It
stored
its
user
as
an
as
a
property
and,
as
you
can
see,
we
redacted
this
as
well.
So
it's
it's.
Two
kinds
of
filter,
one
for
the
journal,
one
for
the
activity
state.
So
that's
what
the
redacting
feature
allows
you
to
do,
and
I
think
this
was
part
of
2.5,
although
I'm
not
sure,
maybe
it's
new
with
2.6,
that's
it
for
my
demos.
A
I
think
we
are
on
time,
but
if
there's
any
other
topics
or
questions,
we
can
maybe
take
them
next
time
or
if
it's
something
small,
I'm
happy
to
do
it
now
and
if
nothing
else
then
thank
you
for
attending,
then
then
I
suggest
we'll
we'll
be
here
next
week.
Again
at
least
I
will
be
alright
thanks,
guys.