►
From YouTube: Magento Architectural Discussion -- August, 28, 2019
Description
* GraphQL - Generic Filtering Proposal
* Enormous number of files in var/report
Meeting minutes: https://github.com/magento/architecture/issues/235
A
B
B
Okay,
so,
as
you
well
know
like
we
are
redefining
the
filtering
or
the
thing
is,
we
came
up
with
the
problem,
wherein,
whenever
a
customer
filterable
attribute
is
being
added
to
the
product
it,
it
has
to
be
reflected
on
the
schema
so
that
the
clients
can
use
it
attribute
to
filter
it.
The
problem
is,
we
need
to
refresh
to
clean
the
cache
and
the
fresher
schema
every
time
and
attribute
is
being
added,
so
it
is
quite
an
expensive
operation.
B
So
I
came
up
with
the
proposal
where
in
its
kind
of
a
generic
filtering,
so
you
give
the
the
possible
the
the
attributes
which
can
be
possibly
filtered.
You
know
in
a
generic
format
like
so
there
are
like
three
three
different
types
of
filtering
1
is
equal
filter
where
you
can
see
the
where
you
can
do
the
equals
operation,
and
there
is
a
like
filter
where
you
can
do
any
like
operation,
and
that
is
arrange,
filter
bar,
which
is
for
the
price
changes.
B
So
these
are
the
only
three
possible
types
of
filters
and
if
we
can
take
the
attributes
for
this
filters
in
form
of
an
array
and
then
so
the
on
the
back
end,
we
can
consume
this
different
attribute.
So
then
we
can
do
the
possible
filtering.
So
instead
of
refreshing,
the
schema
every
time
whenever
we
add
an
attribute,
this
can
be
used
as
a
generic.
Filtering
I
only
share
this
with
Alex
and
Olga,
and
they
already
have
comments.
So
not
sure
if
you
have
seen
this
already
I
have
any
comments
on
this
Olga.
A
Yes,
like
just
my
general
comment,
is
it's
not
so
you
mostly
describe
how
obligations
will
work
on
for
aggregation?
It
looks
fine
like
you
just
want
to
get
different
like
aggregation
by
different
fields
and
probably
that's
fine,
while
I'm
not
sure
how
it's
supposed
to
work
for
filtering.
So
you
usually
want
to
filter
by
specific
field,
and
if
you
don't
have
ski
Mahad,
how
can
you
do
it
if
you
don't
exist.
B
So
the
filtering
is
driven
based
on
the
output,
so
whenever
the
client
goes
to
the
front
and
he
searches,
though
the
the
aggregations
are
being
written
so
which
is
in
the
new
model
as
well,
so
the
clients
will
know
what
are
the
possible
fields
that
can
be
filtered
on.
So
it
need
not
be
essentially
present
on
the
schema,
but
rather
it
is
driven
from
the
output
of
the
previous
query.
So,
let's.
A
Look
at
the
scenario
so
I
want
to
filter
products,
somehow
most
likely
I
know
how
I
want
them,
so
the
research
probably
and
then
there
is
layered
navigation.
So
this
is
in
context
of
learn
a
vacation
right.
We
are
discussing
yes,
and
also
there
is
sorting
as
well,
which
is
not
part
of
layered
navigation.
Yes,
you
just
want
to
sort
by
something,
and
then
somebody
can
implement
just
custom
search
like
as
we
have
advanced
search,
for
example,
where
you
would
need
to
specify
fields
by
which
you
want
to
filter.
A
C
A
B
So,
let's
see
another
case
right
so
when
we
are
dynamically
updating
the
possible
attributes
of
the
schema,
it
might
even
like
go
beyond
like
hundred
different
attributes
right,
but
still
for
the
clients.
You
know
what
are
the
possible
stuff.
They
can
even
show
on
that,
you
wife,
so
how
will
they
even
know
like
what
else
have
they
can
possibly
show
under
you
it?
It
has
to
be
driven
by
the
aggregations
right.
A
Guests
of
so
in
one
one,
schema
changes,
schema
changes.
If
some
somebody
goes
to
admin,
for
example,
and
creates
another
AV
attribute
right
or
somebody
goes
to
the
cold
or
installs
extension,
and
it
adds
some
custom
attributes,
probably
right
what
other
use
cases.
So
it's
either
code
changes
with
or
it's
an
AV
attribute
added
on
the
admin.
We
probably
are
not
very
concerned
about
the
first
case,
because
in
case
you
update
the
code
most
likely.
Yes,
you
need
to
check
your
PW
a
as
well.
Maybe
you
can
add
more
features.
A
B
And
the
clients
need
to
know
that
an
attribute
has
to
be
app
has
been
added
and
they
have
to
clear
the
cache.
And
so
the
thing
is
I
am
not
aware
if
there
is
any
cache
tags
associated
with
a
graph
given
schema
invalidation
and
whenever
a
graph
itself
is
invalidated,
the
schemas
stitching
and
the
schema
parsing
takes
a
lot
of
time
compared
to
like
any
other
invalidation.
It
takes
at
least
like
more
than
a
couple
of
seconds,
which
is
going
to
be
a
very
expensive
operation
compared
to
other
in
validations.
Yes,.
A
D
D
A
D
Idea
is
basically
to
to
have
two
possible
interfaces.
One
is
querying
the
schema
and
detecting
custom
attributes
presence,
maybe
identifying
them
with
a
directive
for
Build
time,
and
the
other
would
be
a
an
interface
much
like
this
proposal.
It
looks
good
because,
like
you
said,
we
need
to
iterate
at
runtime
as
well.
We
were
just
hoping
to
also
have
this
information
present
in
the
schema.
A
Proposal
is
to
describe
use
cases
and
expected
so,
for
example,
one
workflow
is
adding
a
custom
attribute
which
happens
in
the
code
and
just
let's
describe
who
is
involved.
Who
should
be
doing
what
like?
How?
How
PW
a
developer
will
be
affected
like
how
you
should
interact
and
then
what
happens
if
an
admin
creates
an
attribute
right
now
we
need
to
clear
the
cache
and
then
PW
application
somehow
also
needs
to
know
that
schema
is
updated.
So
I'm
not
sure
if
this
happens
but
another,
so
it
would
be
good
to
have
those
flows
described.
A
It
would
help
to
understand
us
what
we
want
to
achieve
and
what
will
be
the
most
optimal
solution
and
another
note
that
I
have
is
that
schema
is
just
one
part.
The
graphical
is
just
one
part
which
is
just
presentation
layer,
but
then
there
is
also
indexing
of
the
data
itself.
So
when
an
attribute
is
added,
it
can
potentially
say
like
I
believe
it
can
have
some
default
value
or
whatever
or
if,
when
we
move
to
separate
data
storage
for
storefronts
api's,
which
will
be
used
by
graph
GL.
A
E
A
F
I'll
yeah
I'm,
sorry,
one
more
thing:
you
propose
to
remove
cache,
but
we
still
need
to
get
some
data
that
was
cached
before
and
it
actually
means
that.
Yes,
we
are
saving
two
seconds
on
schema
regeneration,
but
now
we
need
to
extract
the
same
data
for
each
request,
but
probably
it
will
impact
have
some
impact
on
performance
over
storefront
API
or
something
like
that.
F
B
F
B
Even
I
think
aggregation
type
should
essentially
solve
the
purpose,
at
least
what
I'm
trying
to
achieve,
but
yeah
I'll
I
was
like
little
underprepared
for
this
meeting,
because
I
didn't
know
that
I'll
update
the
workflows,
what
olga
suggested
and
what
you're
interested
so
and
then
I
can
get
back.
So
we
can
discuss
in
much
more
in
detail
and.
G
A
If
not
I'd
like
to
discuss
another
one
totally
different
now,
I
don't
have
a
proposal
and
a
proposal
will
be
prepared
a
little
bit
later
by
dev
team,
but
I
just
didn't
want
to
like
wait
another
week.
So
I
wanted
to
start
the
discussion.
So
the
problem
that
we
have
and
I
can
share
the
screen
for
people
who
like
to
read
more
than
listen.
There
is
some
description.
It
will
be
more
organized,
probably
in
the
proposal,
but
in
general.
A
A
A
couple
of
reasons
that
we
discussed
is
it
can
be
that
something
happened
just
happened
in
the
application
and
we
have
repeating
error
like
the
same
error
message
locked
in
envelopes
and
if
it's
a
rush
time
so
like
I,
don't
know
if
it's
Black
Friday,
for
example,
it
it
will
build
up
a
huge
box
eventually
pretty
quickly.
So
that's
one
issue,
that's
one
reason.
A
Another
reason
is
that
the
logs
can
be
just
ignored,
like
some
exception
loads,
so
I
would
usually
expect
that
those
shouldn't
be
ignored,
but
probably
you
have
to
analyze
what
kind
of
logs
are
being
ignored,
like
what
kind
of
exceptions
might
be?
There
is
something
in
magenta
that
causes
people
saying
that
this
is
not
an
important
issue
like
it's
not
really
an
issue,
but
it's
been
logged
as
an
error.
Maybe
there
are
real
errors
and
people
just
don't
get
to
fixing
them
so
anyways.
A
So
one
proposal
is
to
have
at
least
some
nesting
level
because
one
of
the
issues-
it's
not
even
disk
space,
but
inability
to
even
list
the
files
in
there,
because
there
are
millions
of
them
and
the
second
part
of
the
proposal
is
to
log
on
the
unique
unique
exceptions
in
the
report.
Report
includes
backed
rice,
so
it's
like
big
amount
of
data.
A
If
we,
if
we
take
into
account
that
there
are
a
lot
of
such
files,
so
the
proposal
is
that,
in
the
exception,
would
be
just
an
error
message,
but
we
create,
on
the
one
exception,
a
report
log
for
each
kind
of
not
each
kind
of
error,
but
for
each
error
that
we
have
so
we
don't
duplicate
them.
So
it's
based
like
there
is
some
prototype
implementation.
It's
by
based
on
calculation.
A
You
can
calculate
in
hash
from
the
like
from
I
believe
from
the
request
to
based
on
the
request
and
probably
like
exception,
so
based
on
some
unique
values.
We
calculate
hash
and
we
create
file
with
the
name
of
that
fashion,
and
only
and
eventually
we
have
only
one
such
file.
It
should
also
help
with
repeating
errors
so
that
I
just
wanted
to
start
the
discussion
discussion.
Maybe
somebody
has
like
totally
different
opinion
might
be.
A
F
E
H
I
F
Issues
with
multiple
files
and
that
directory
couldn't
be
rotated
or
something
like
that,
and
regarding
the
possibility
to
remove
duplicate,
it
seems
not
very
long
negative
mechanism.
So
usually,
if
you
have
this
similar
entries
in
the
four
files,
you
still
keep
them
with
times
time
with
everything
and
just
compress
them.
So
usually,
if
you
have
the
similar
message,
it
could
be
compressed
pretty
well.
H
A
I
A
H
F
Recommendation
on
tap
talks
about
magenta
installation
and
there
is
post
installation
steps
that
say
that
we
need
to
the
top
of
rotation
links
and
also
we
can
try
to
use
the
virtualization
techniques.
For
example,
we
may,
if
we
decide
to
create
a
docker
image
for
Magento.
We
can
include
of
rotation
like
an
ism
inside.
J
Visualization
of
the
box
instance,
there
are
tools
like
Splunk
that
allows
you
to
visualize
walks.
Maybe
we
can
turn
in
for
for
services
relation
we
go
have
to
build
some
log
aggregation
and
visualization,
but
we
can
probably
add
part
of
this
model
it.
It
would
be
like
much
easier
to
see
what's
going
on,
for
instance,
on
the
cloud
it
can
be.
A
J
J
A
I
Stack
traces
I
think
it's
pretty
important,
maybe
it's
more
than
documentation
thing
it.
Maybe
it's
not
even
necessarily
an
implementation.
I
mean
I,
absolutely
recognized
the
issue
of
having
many
many
files,
and
that's
it.
That's
an
issue.
I
think
we
probably
should
address
but
having
the
the
ability
to
pull
stack
traces
for
observability
I.
Think
it's
very
important.
Maybe
it
is
just
simply
about
communication
situation.
Maybe
we
start
at
the
base
level.
I
A
So
I
wanted
to
get
back
to
what
Andrew
connoisseur
told
about
duplicating
messages.
I
just
want
to
clarify
the
solution.
The
solution
is
that,
in
the
exception,
log
V's
or
maybe
it's
system,
log
I
think
it's
pretty
confusing
right
now,
so
let's
say
it's
an
exception.
What
we
still
have
all
these
repeating
messages,
but
we
don't
have
stack
trace.
So
if
it's
repeating
we
will
have
multiple
masts
and
multiple
records.
What
we
don't
want
to
repeat
is
this
report.
Log,
which
includes
stack,
trace
and
I,
mean
we
can
probably
move
it.
A
Move
stack
trace
back
to
back
to
the
exception
log,
but
then
it
will
probably
be
harder
to
like
read:
I,
don't
know
to
not
duplicate
stack,
trace,
I,
don't
know
if
it's
a
big
problem
or
not.
But
if
we
are
talking
about
millions
of
such
files,
we
will
have
millions
of
Records
unless
log
rotation
is
not
set
up
properly
like
if
there
is
some
kind
of
spike
yeah.
H
A
No,
for
me,
it
looks
pretty
convenient
as
it
is
right
now.
We
have
exceptional
obvious
messages
in
general,
we
can
see
when
it
happened
and
how
many
times
it
happened,
and
then
you
can
actually
go
to
the
report
log
and
see
back
trace
if
you
really
need
it,
what
we
can
probably
reckon
see
there
it
in
the
fish.
So
let's-
let's
summarize,
let's
summarize
so
first
thing
is
considered
removing
reporting
and
under
removing
reporting,
good
daemon
and
removing
all
those
files
at
all
and
just
putting
everything.
H
A
C
B
H
Their
buses
still
different
problems
that
look
a
greyish
at
all.
It's
not
about
work
at
all,
so
our
current
looks
is
work.
Well,
we
aggregated
and
it's
dream
latent
for
work.
Well,
it's
about
representations.
Is
that
not
is
store
data
in
separate
file,
and
it
includes
much
more
information
that
just
looked
in
killed.
J
To
have
exceptional
organ
not
to
have
this
report,
but
good
I
also
notice
that
most
of
these
reports,
the
stacked
rings,
is
not
very
helpful
there,
because
you
would
just
see
object,
manager
trying
to
initialize
some
classes,
but
you
even
don't
know
what
those
classes
are,
because
the
pass
is
truncated
after
Magento
namespace
like
it
would
be
Magento,
slash,
ends
and
truncated,
maybe
name
of
the
part
of
the
name
of
the
module,
but
that's
it.
Maybe
we
can
also
look
into
improving
set.
A
A
So
like
we,
the
idea
is
that
we
want
to
consolidate
everything.
In
the
exception
log.
We
need
to
figure
out
what
we
do.
This
stack
trace-
maybe
we
just
put
it
in
there
and
we
need
some
good
guidelines
on
how
to
set
up
your
system.
So
you
have
log
rotation
or
whatever,
and
some
monitoring
to
not
forget
about,
like
to
not
miss
all
those
exceptions
and
just
build
up.
A
A
Regarding
this
digital
nesting
level
that
we
want
to
introduce
so
I
didn't
hear
any
opinion
about
that.
So,
in
my
opinion,
in
won't
really
solve
the
problem
might
be
try
other
opinions.
Should
we
introduce
this
nesting
level,
so
I
just
would
have
several
folders
on
then
pulled
files
in
there.
So
you
will
have
not
millions,
but
maybe
I,
don't
know
100
thousands
in
each
folder
or
whatever.
There
is
also
an
approach
to
have
nesting
level
starting
from
a
year
and
up
to
a
minute.
H
A
So
this
is
one
approach,
and
this
is
what
we
want
to
implement
in
in
magenta,
instead
of
just
having
watchful
cloud.
Another
approach
that
I
heard
from
support
team
is
having,
as
I
mentioned,
like
year-month-day,
probably
I,
don't
know
R&B,
not
like
it's
bigger
nesting
yeah.
My
question
is
whether
we
even
should
look
into
nesting,
or
we
should
just
focus
on-
maybe
removing
this
reporting
at
all
the.
A
E
Some
artifacts
actually,
for
example,
if
we
have
like
payments
concept
like
payments
request
log
and
the
merchant
facing
the
problem,
is
like
some
transaction
which
made
like
months
ago.
It's
actually
hard
to
find
this
transaction
because
give
you,
for
example,
you
know
you,
you
know
the
date,
but
you
don't
know
actually
how
to
find
in
your
custom
logo
data.
If
we
have
some
defined
mechanism
like
agreement,
some
lobe
rotator
will
be
done
divided
by
day,
so,
for
example,
by
months,
etc.
It's
easier
for
even
for
debugging
purposes,
to
fight
something.
Oh.
F
I
A
I
A
Guess
I
was
not
present
when
it
was
introduced,
but
one
of
the
features
that
we
have
in
magenta
is
when
you
are
in
production
mode,
so
you're
not
supposed
to
see
an
error
with
back-trace
on
the
page.
You
are
shown
a
file
name
like
report
name,
it's
just
some
digits,
I,
don't
remember
it's
maybe
timestamp
and
then
like.
There
is
a
message
that
go
look
into
this
report.
So
if
you
have
access
to
the
file
system,
you
can
go
and
find
that
report.
It's
like
an
identifier,
yeah.
J
I
Yeah,
so
the
basic
idea,
blog
rotation,
is
exactly
that.
Yes,
you
just
kind
of
purge
out
and
rotate
the
logs
that
exist,
but
part
of
law
patient
as
a
practice
is
really
pushing
that
data
that
log
data
out
to
a
some
kind
of
analytic
system
that
you
can
then
store
long
term.
So
you
can
run
either
short-term
or
long-term
analytics
across
the
the
data
set
over
a
long
periods
of
time.
If
you
so
choose
so
yeah
well,
part
of
it
is
purging
that
data,
it's
also
storing
it
as
well.
A
A
A
I
Just
for
specifically
your
fire
hose
that
you
can
then
generate
those
logs
and
push
that
into
various
different
analytic
systems.
It's
actually
fairly
easy
to
set
up
as
I
think.
If
we
explained
it
to
them,
would
be
very
pretty
easy
for
them
to
actually
set
up
for
their
customers.
I
think
would
go
a
long
way
towards
getting
visibility
into
this
type
of
information.