.Net Foundation Design Reviews, 2 Jul 2020

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: GitHub Quick Reviews

Description

00:00:00 - Approved: Add a new `unmanaged` calling convention bit for use with function pointers https://github.com/dotnet/runtime/issues/38133#issuecomment-653130834
00:18:14 - Approved: `System.Runtime.CompilerServices.RuntimeFeature.UnmanagedCallKind` https://github.com/dotnet/runtime/issues/38135#issuecomment-653135036
00:27:46 - Rejected: Add NativeIntegerAttribute https://github.com/dotnet/runtime/issues/38683#issuecomment-653136856
00:32:08 - Approved: Flexible and efficient optionally-structured console logging out of the box https://github.com/dotnet/runtime/issues/34742#issuecomment-653193414

A

A

A

All right, good morning, friends, uh we will start with some c-sharp things for function. Pointers. I don't know who wants to talk to you whether it wants to talk to you who wants to talk about it is either tanner or fred fred. Do you want to give us an.

B

A

B

I can talk about it. um Are you gonna stream, the proposal, email.

A

Oh sorry, like it's on youtube, it's not here like. Let me just quickly open the sharing tray find the right window.

A

And, of course, teams minimizes again.

B

All right um so, basically uh there's a couple of couple of pieces to this. um Runtime of the compiler have sat down and we worked out basically a api for allowing extension, extensible calling conventions. So today, when, when you encounter a calling convention or when you encounter a method signature in il, you have uh basically the the call kind bit is what describes the calling convention. So we have defaults, which is a managed function, normal normal clr, and then we have a whole bunch of unmanaged uh calling conventions. We have cdecl stood.

B

Call this call and fast call uh the new one that we want to end envirox, but we're not really talking about ours right now. um The the new one we want to add is called unmanaged, and this means a few different things depending on context.

B

So if unmanaged tells the runtime look at the set of mod ops that immediately follow the parameter count in il if those modops have are are of a specific type, they come from system.runtime.compiler services and they start with the name callconf. Today we have in this in this namespace. Today we have types for qualcomm seat, echo call, column, stood, call call com fast, call call con for this call um those those have existed in the framework since uh since dot net framework 1.0.

B

um So look at look at those set of mod and take the combination of them and that's that's the calling convention to use, uh and so this will allow the run time to add things in the future uh like, for example, vector call without having to change the calling convention bit, because we don't have that much space, and it will also allow the runtime to add things like suppress, gc transition to act as a part of the calling convention, something that should be considered in the type system of c sharp.

B

When we're talking about function, pointers uh because a a function that actually has suppressed gc transition on it shouldn't be converted to one that doesn't have.

B

It shouldn't be converted to a function pointer that doesn't have that transition on it, because it might expect things to be that way or not and then same for vice versa, and if there are no calling conventions so going back to the mod-ups.

B

If there are no calling convention mod ops in that set, then the runtime will interpret this bit as use whatever the default is uh so on linux it well, I believe it will use, uh stood, call no cdecl and then on windows is stood call basically whatever whatever the the c plus compiler would actually emit. Normally, if you don't specify anything for that platform um yeah, so that's the that's what this is going to represent and then we need to add it to srm.signature calling convention. So the compiler can actually emit this bit.

A

I yeah, I think that part makes sense to me so, like you said, oh there's something about mod ops and combinations, but where does that stuff live? Because this is just adding this bit to the enum? That is part of the metadata.

B

So those are required to come from the the specific namespace system.runtime.compiler services, they're required to start with callconf, and they are required to come from the core library of the application, meaning the library that defines system.object and references. No other libraries, okay,.

C

B

Already, we've already moved so dotnet framework. This is fine and everything's. An ms core level. um Dotnet core prior to 2.0 uh doesn't have these types at all.

C

B

2.0 added the four types that existed in framework um and they added them to system.runtime, not system private corelib, but we are basically special casing in the compiler, the four, um the four types that existed, always uh as not even not even we're not even going to look up the types we're just going to recognize that cdec will stood called this. Calling fastcall are valid things um and then for net framework. Five, we moved those uh to system private, coil, dotnet, framework.net, five. We uh we moved the those four mod up types to spc.

A

Yeah, I think my question was even more basic. It's like, I think we already have the api approved. I believe right because it I'm pretty sure we already have the like. There was a meeting on the um on the required mod up that we put in system runtime compiler services, I believe for unmanaged um okay. So then this is literally just this one bit that we would have.

B

We need a bit in signature calling convention so that we can emit it in the compiler and then there's a related one for um uh the runtime flag, which I assume is the next. The.

A

Next proposal um yeah so like by the way, if we add an enum member here, does that mean we have to rev the l format for that or how does that work?.

D

No, so you can already. Can you hear me yeah? Yes, okay, sorry, you can already using ilasm, basically encode whatever bit value you want. So, for example, in il you could type 0x9 as the value of the calling convention and that will encode as 9..

D

It won't be usable on a runtime that doesn't recognize it, but you can already encode it use it, etc.

A

I see so adding members like. Basically I guess the spec says there's a value. If you don't know the value, then you fail at one time, but it's still valid in metadata.

D

A

All right, so that makes sense then.

D

So essentially, if you're on an older runtime, so not.net five, the runtime will encounter the the bit um and it will do whatever that run time. Does I'm assuming it will uh throw an exception in fail fast, probably a type load exception uh and then on the newer runtimes. It will actually interpret it and use it correctly.

B

E

B

That that particular bit is what the next the next api is going to be used for as well.

A

And so like unmanaged is already a term that we use elsewhere or because I think we have the term unmanaged code before, but we never use the calling convention for that. It's just literally native code.

B

So if you look in 335 the way that all of the existing um bits are specified are as either default or unmanaged to exactly unmanaged to call unmanaged, this call unmanaged fast call as two words. um There is some question as to whether, in my mind at least as to whether or not as just unmanaged is a good term here right.

F

B

What I've been viewing it, as is more like unmanaged extension, um because it's like this is the unmanaged extensibility bit.

A

So basically, it's the platform default right really.

B

Yeah, well, not necessarily it's unmanaged platform default, and this is what jan brought up when we were talking about naming was it's unmanaged platform default or the combination of mod ops on the return type, if specified, which is not a name. We want to.

D

Right so so, and so in.net so in.net 5, the only valid thing will be unmanaged. uh You can't have any mod ops on it. The runtime will fail. The plan is, for example, for net 6. We will extend it so that at a minimum, gc suppress transition, call conf, gc, suppress transition is a supported, mod opt if that exists. The gc will treat it as if uh it has the suppress un suppressed gc transition attribute um it's not being encoded as an attribute because function, pointers, don't support attributes.

D

So we have to do this new thing to support it instead and in the future, we may have, for example, a call con vector call bit uh which allows you to say uh this is the vector call, and this is how we're going to support it moving forward, because we have a finite number of bits, and there are, you know, 20 plus calling conventions defined in uh llvm and clang that we could theoretically support someday. There's also other scenarios such as stood call plus.

D

This call, which is used in com interrupt, and it is actually a combination of both rather than uniquely either. I.

A

See so it really like what what fred just said? It's basically true, it's just like yeah there's a calling convention, it's expressed as mod rex, so look at the return type.

D

Right, it's basically saying this is an unmanaged calling convention. If there's no mod ops, then it's the default. If there are mod ops, then it modifies the default calling convention based on that mod.

A

Yeah, I guess I managed just fine, I mean it's a I.

D

A

It seems like they all are very specific anyway, so you have to kind of read the manual, so it seems fine, it's just the only question. The only reason I'm asking is because we use unmanaged usually as a very broad stroke, and it didn't seem very specific in that sense, but it seems like the specificity here comes from other data that is elsewhere, so it makes sense to be fairly vague in the name.

G

A

B

Return applies.

B

What was that sorry.

G

So what about something.

B

Like return attribute defined well, so if I guess that that is technically true, if you don't have any any mod ops and well, it would be not attributed to be mod. But it is technically true that if there are no return types, no no return types, mod ops, then uh it is defined by it.

H

G

Mean or yeah return return, ops defined or something like something that says this is this is where you go to find. The answer like essentially what it means is external right of. I don't have the answer here, go ask someone else, but if we invent a new pattern later, it's external one and external too. So just trying to say right now that this is you know, return ops, defined.

D

Well, it's not even necessarily return mod opt it's part of the type, not necessarily the return value and.

B

D

B

It's whatever the first monops are after the param count, which means that it goes before the ref if one exists and they're technically on the return.

D

Type all right, but I I think the general point is- is that this is the unmanaged calling convention. It's unmanaged, just the direct counterpart to managed managed being the stuff that clr creates and unmanaged being the stuff that the clr does not create.

B

uh And also I do I do want to point out. There was so we do have prior art here, in that the p and vocal equivalent of this is win api, uh which we don't want to put into our we. We regret putting win api as uh in it in the first place, and we don't want to do that.

A

B

uh But that is the technical prior art.

A

Right yeah, I mean to me the only reason why I wouldn't put in, like you know, return type defined in it. It's, like god forbid. We ever find another creative way to put mod rex elsewhere and then now the enum is misnamed right. um We could call.

B

It mod up to find.

A

Is it mod opt or mod rack? It's.

B

Mod opt, but I guess we don't necessarily we, I guess in some future world we could do mod wrecks.

G

B

Mostly because that's what the c plus plus compiler did so rack.

G

Is really like opt plus plus right, so you can sort of hand, hand wave at that one.

A

I'm surprised that it's not a mod rack because technically like if you don't know what it means you shouldn't call the method right, because your layout will be.

B

Well, so what c, plus plus we're kind of following the the c plus back here, which is um uh they would put not only the calling convention bit, but they would also put this mod opt on the return type um and so it so. Yes, if you don't know what it is, you shouldn't necessarily interpret it, but the language that itself doesn't really need to know about um the whole point of this design was the language doesn't need to know what valid combinations there are. It just needs to take them.

G

B

G

The compiled but required to the runtime yes.

D

G

D

335 spec also explicitly uses the term unmanaged to refer to unmanaged calling conventions, unmanaged code, etc. I I honestly don't think that something more explicitly named is going to be clearer when viewed in combination with the ecma spec.

A

I mean the only thing we could do is like give it a name like modifier defined or something right, but, like I think I managed is also fine like, as I said like all of them. You basically have to look up but yeah. Basically the idea would be we give it a name that is kind of sensible, but at the same time, if there's a mapping table, you have to consult to see like what the layout is right and the mapping.

G

Table might say.

A

Go look at the return type specification.

G

Yeah, because my only oddity with unmanaged is honestly a fast call, or this call a standard call and a c decal are all unmanaged calling conventions because they're not the managed calling conventions.

C

G

And so it's it's a weird like. I know we're not a flag zenum, but does it feel like it's trying to be hyper, inclusive or say any and go figure it out? But it's not it's saying like there's different rules and they're over here, and so I I would slightly prefer that we indicate that it's you know.

G

Mod defined or whatever like, but if unmanaged is the best word we can come up with. I I don't care a whole lot.

B

I had been using unmanaged extensible in my in my documents, as just a placeholder word, for whatever we come up with, could use that.

I

It seems like the user just needs to know what a lot of these mean anyway. So a super clear name, maybe doesn't get us a huge amount here.

A

Yeah I mean I at this point. I would just literally go with the proposed name, because it seems the easiest one.

D

A

D

There's also other considerations like cdecl doesn't exist on x64 or on arm platform conventions, in fact, on a arm platf on arm platform, cdecl standard called this call and fast call will all produce the same code gen uh they can. The c-sharp compiler still won't allow conversion because of type identity, but they are all the same and they don't actually apply there.

D

There's so much consideration you have to put in once you get down to I'm emitting il metadata and what is and isn't compatible that users really need to refer to the spec for this stuff.

H

Along those lines, what audience do we anticipate actually using this particular enum.

A

H

People who are already familiar with 335.

A

D

You basically shouldn't need it need to use this enum unless you are reading or writing metadata either because you're dynamically constructing types or because you're, a compiler.

G

Yeah so like looking at ecma three, three, five and two, I think that's two and not eleven dot 15.3. It talks about the existing ones. We already have here as unmanaged cdecl, unmanaged fast call, unmanaged standard call unmanaged this call. So it does feel weird that we just now have this bear word unmanaged um it. So it feels.

D

Weird to me, but when you think about it, in the terms of il just unmanaged by itself is unmanaged platform default, so no modifier unmanaged cdecl is then uh unmanaged calling convention cdecl modified and then once you get into modops, you would have unmanaged mod, opt vector call, which logically reads as unmanaged vector call and therefore is fluent in the same pattern. So.

C

D

Were writing il you would read it essentially the same way. You would just encode it slightly differently.

A

I I I suggest we move on, given that the api is used by five people in the world. Indeed, uh all right, so I just marked it approved, as basically is, unless somebody has stronger position. I would go ahead with that all right. So then this is.

B

The corresponding other thing, then I guess yep, uh and so basically this feature of the runtime that would support this unmanaged flag. We would like to be able to detect when the runtime supports it in the compiler.

J

B

I'm proposing adding a flag to runtime feature that we can look at.

A

So this was one of the things where we had some discussion on, whether we should do it or not right. I think jan basically said something on the lines of like, instead of doing that probe for the presence of the attribute, and then I think you said well, there's a they're not strictly speaking tied to each other right. So right.

B

So uh the after the attribute thing is uh unmanaged callers only which is an attribute being added to uh dotnet five, uh which users can put on a method on a static.

K

B

Then, when the.

K

Runtime sees that method.

B

It will actually emit a stub that is the unmanaged calling conventions convention specified by that attribute. C-Sharp. Won't let you directly call that method. You must directly convert it to a function pointer with that calling convention on it. um So we could use that attribute as the as the flag here um there'd be a couple of things. We would need to change. Well, there'd be one thing we need to change. Currently, the attribute, I believe, is defined in system runtime.

B

uh We weren't going to require that that attribute is actually defined in system private core lib, but if we want to use that attribute as the detection mechanism for whether or not um this the runtime supports this feature, it needs to be in the runtime, um so it would need to be in system private, core level.

A

Yeah so but it's one of those areas where.

B

L

Right, sorry, sorry, I just have a quick question for clarification. Several times, you've made a distinction between private correlate and system.run time, but from the compiler's perspective it doesn't see it's just a private correlate. So.

B

The attribute needs to be defined to the compiler's view in the library that defines system.object and has no references.

D

Which is the system.

B

Okay, so then it wasn't defined and then jan asked me if this needed to be in the same library that defines uh uh the the call consideral types- um and I said not necessarily so I assumed that meant it wasn't.

A

So basically, what you're saying is because you're you're inferring runtime behavior- you don't want this type to be in some random assembly. That potentially is user-defined right. You want to make sure that this is coming from the runtime and one of the easiest way to do it is to say it's the call-it right.

H

Just I just wanted to make sure we weren't doing anything weird like with the compiler trying to reference it.

D

H

H

Tenor go ahead.

B

D

Run time interrupt, sir.

B

I think he said it's in system.runtime.net, interrupt services, yeah.

D

It's in that ref assembly today, and if we want it, we have to move it down to runtime. It is in correlate, but it would need to be moved down to system runtime if the compiler wants to depend on it.

A

I think to me, like yeah, like to me honestly at this point that seems more like a wash then like I'd rather add a. I think I guess a filter. One time feature that seems cleaner than doing you know some crazy gymnastics with type forwarding. I mean it kind of makes sense to me that runtime behavior is something that runtime needs to define, not the user right, so either keying it off of callip or the runtime feature type seems reasonable, like we originally invented.

A

Runtime features for for things that you can't key off of api surface right, but I kind of agree with uh after 10 antennas. After forgiving more details, it seems weird to keep off of the attribute, because it's kind of like some random other type, that is part of the feature set, and that seems not very straightforward. It's almost like saying the runtime supports async, because some random s method exists somewhere.

A

It's supposed to you know, task of t right so, like that seems kind of similar here, like the calling convention, is really like a core concept that runtime has to support, and as such, I I probably would prefer a field as well here than some random type, that we now also have to type forward down to system.run time. That seems weird.

B

Well, I don't think we'd actually have to type forward it because um we're adding it in this in f5. So.

A

Oh, I see so we would just edit some system runtime. Instead of one top services yeah, I mean it kind of yeah. I guess that's fair.

B

A

B

I would I'd still prefer this. This solution, mainly because they're different features right, like unmanaged calling convention or unmanaged colors, only is being added at the same time as this, but it's not this. It's not. This.

D

And a runtime, a non-microsoft owned runtime implementation could theoretically implement one, but not both if they are separate.

D

A

Yeah, does anybody have any concerns of adding it to runtime features? I think jan basically just said, let's not make this a dumping ground for all new compiler features, which I think I agree with, but this seems more like a runtime type system constrained which to me honestly belongs to runtime feature.

D

Yeah, because f sharps are also going to need to check for this. If they eventually add function, pointer support, um as well as any other language.

A

Well, true, I mean that doesn't mean it has to be this right. It just means whatever mechanism we envision. Every compiler would have to use the same mechanism for that, um but yeah that also kind of makes it harder to explain when it's like. Well, you know, for these one-time features, use this thing and for these other runtime features use this other mechanism. That is.

D

Well- and I I think one of the other interesting things is mono, for example, mono might want to bring in the new attribute for suppress for unmanaged callers only, but they might not have implemented the new runtime feature for uh for.

K

One minute.

D

Yeah for for general, unmanaged calling.

D

B

I hear no objections.

A

Yeah, I'm just typing, um but it seems runtime type systems uh type system constraints would belong to.

A

All right, so let me just paste this in so that.

D

Here, there's also one other compiler attribute request um for uh that's blocking, which is the add native integer attribute, I believe, fred's the secondary reviewer on that for chuck.

B

uh Maybe you know that you shouldn't.

D

Have dinner uh three eight six, eight three.

B

uh At eight three, six, eight three.

A

D

It's relatively straightforward: it's just a an attribute that that allows encoding, whether a given return or parameter is native int versus int, pointer.

L

F

L

Of adding this is mainly that we avoid duplication with the compiler having to emit itself into every assembly.

D

Right, the the compiler will emit it itself if it doesn't exist, uh but that can you know that's going to require redefining uh native integer attribute in any assembly that defines it. So it's similar to the other similar things we've done like for nullable um and other bits.

L

I thought I thought the compiler like generates this attribute for you. It's not like no, like with nullable you'd, have to copy and paste the attributes you want to use in.

B

No, no, no, the compiler, the compiler will generate the nullable attribute as well. If it's not.

L

But you're talking the nullable attribute not like the not.

B

Not not maybe null not not, users.

L

Don't use thing right, but in the null block case like we didn't add that to the framework did we no.

A

L

B

A

We did not like this.

B

I'm wondering why this one's special.

A

So basically, the bar that we had, as we said, we only add attributes that users are referenced manually because that's a pain in the ass, so they have to copy and paste the definition of the attribute. So everything that the user is is expected to put in brackets, we will add for things that the compiler will synthesize. Happily, we basically said we don't care and we ended up, not adding another ball. I mean, I think there was some kind of metadata upload, but I guess the argument was it doesn't really matter because it's so tiny.

A

L

One per assembly yeah: it's.

A

One per assembly and they're not big to begin with.

B

Yeah I mean they, don't they don't need to be reference equal, I'm I'm messaging chuck right now. He hasn't seen my message. Yet um I'm not exactly sure what um can you scroll down? Maybe he he talks more about uh why he.

A

No okay, there's no context. I can just respond to this and say for now we assume it's only needed by the compiler, so we would say uh we wouldn't add it.

B

I mean I, I think it's the same as nullable attribute and if we didn't add that I don't know why we need to add this, but I'm not. There could be something missing.

D

We've also added a several other ones that the compiler auto synthesizes, though.

D

I'm trying to pull it up right now, uh but most as far as I'm aware, most of them, except for nullable, we've, actually ended up adding helpers for over the long term, just because it it allows other compilers to key off the same one without also synthesizing their own type and just makes things overall.

D

D

Sorry, my internet's being very spotty right now.

I

Tanner, what's the point of adding this attribute to a class.

D

uh I believe it allows you to encode, so so, just like with nullable, you can put it on a higher level to encode uh to encode things more more explicitly. It allows you to save on metadata bloat.

B

D

So, for example, you you could encode the fields all at once, rather than encoding it on every individual field.

A

Yeah so, like I I'll just let's say, let's just close it, and then I mean if, if there's a reason to bring it back, then we just reopen this like. uh I just want to avoid like holding the whole meeting hostage on this one, because we don't.

A

A

All right so then,.

B

All right, as long as that was it for me, I.

L

Think that was it yeah.

B

I'm gonna wait five seconds this time before logging off, so that aaron doesn't ask a question immediately after I close all right thanks. Everyone thank.

M

You wait, I have a question.

M

A

um So this one already took us like ages last time so who wants to drive this.

C

Hi, did you refresh the page.

A

uh Totally last minute, edits.

A

M

A

On the thing again yep here we go. It's reloading.

C

Yeah, so I have, I have a link in there just I thought I would simplify that what we look at so in the middle I just for the api you stitches on the apis as well.

A

So what should I click on.

C

N

C

New such a new apis, this one here.

N

Oh yeah, okay, so that's proof.

C

Should we wait for uh david to join, let me ping him yeah.

C

Okay, um so until um david joins, I can uh give a walk through of what we talked about last time and then what we wanted to update. So if you remember, um we had for the logger options, um we were using interface, icons, log formatter options and then we were going to use a base class instead. So that's an update towards the bottom of the c ref file.

C

That's one thing, and then there was I console log formatter that um had an issue with like we wanted to see. If we wanted to do format versus right, um hi, that's one of the feedbacks and I think the third feedback was um so uh with this new set of apis. Then we should be able to use like vt100 internally until the bcl uh system console apis are available, and then we can internally replace what we have implemented.

C

When we have system console in the future, um let me see if david joined.

C

um Yeah, so the second file shows usages as well.

A

um So let me try to.

A

Make this slightly more readable.

K

um So maybe we can start from the the list of the feedback we got in the first time I mean we can go through it.

C

That's the last comment and we'll put in the issue page.

K

C

You put a comment there.

C

There was a overload I removed that um we were using this interface icon, so logger options so now that's replaced with base type um abstract base type and then the second two bullet points um yeah. If you remember the conversation about vt 100, um what we, what we talked about is that we we don't want to expose any uh classes or um types in order to write logs.

C

We just pass a text writer and that's what we're doing in the apis and the fourth bullet point says: should I console.log formatter pass the text right so basically the second two bullet points are.

A

A

Okay, so I'm almost.

A

A

Yeah, god knows why that doesn't do syntax or writing, but.

A

It is what it is, so I basically took your gist and I just removed some of the namespaces, so we can.

A

I have to refresh the page for some reason: it doesn't do it. I.

C

Can find it okay.

A

C

A

Because the namespaces make it.

C

A

A

M

A

So we removed all the color stuff from it already right.

C

Yeah, uh the color! Yes, so if you look at there is a interface called, I console log formatter.

C

It has an api called.

C

A

C

Lower at the bottom, I console log formatter yeah, all right, the last interface you see, um we don't we're just passing down a text writer here.

C

It's the last argument.

O

And then the idea is public. Extenders of this would just write antsy codes to get color.

O

Even though we don't have like decent apis for it, they can just hard code the strings in for ansi.

A

A

Let me try to make this okay, so I think I got it now all right, so.

A

What is the flow so, like the usage is basically you. Where do you start? I guess.

C

um In in the just, you can see a bunch of usages, I've prepared.

A

C

um Yeah, so these are the usages and then the last file shows the existing usage and how it you can compare, how it could differ, but yeah. Basically, you can either do line. Three builder dot, add console, which is which would be the existing behavior or.

C

Yeah, so you can specify your formatter, so we have this uh line. Seven shows a new property formatter name. You can specify uh any of the three built-in formatters default, systemdr json, and um so basically, in this lines, between six to nine you're kind of configuring, your console logger options.

C

C

The remaining console logger options are deprecated. So therefore, as an example include scopes or use time stamp, um they would be formatter specific options. So then, um if you want to configure them you're going to configure them with the formatter so line, 3913.

C

Shows usage when you want to not only pick a default formatter, but you also want to configure its options.

K

Look support will have a question here or comment.

F

Oh yes, um question so in in practice, only one of these parameters would be used globally for the application.

F

um Why do we have both add methods and then the ability to set the current parameter instead of having just set methods, search extension methods, so you would call set default or like apply default, console logo formatter or apply json console logo formatter without having to set the name later because you won't be using like registering multiple and using multiple layers, doesn't make a ton of sense, you'll be only using interior. The last one you added or the one you picked.

P

So two things like one is the the scenario where you you use a library to enable more formatters, but you don't turn it on by default. You can imagine in azure, then offering more more like providers, but not setting at the same time, so we wanted to couple adding it and setting it just in general,.

F

Because is it real like yeah, why would you edit without setting it like? Why do I.

P

Need it because they're different actors doing the adding and setting the user? Maybe the user may be the one doing the setting, but they are the one doing the adding so.

F

If we give you, if we ship it for matter, we would have to ship some type with the formatter name. Why won't we ship the extension method directly to enable the formatter.

P

Because, in the cases where you are the one calling it where some library called it on your behalf or if you use an eyehole an I hosting startup, that actually did it on your behalf because you're running in azure, then it's going to add it for you, but it won't actually set the default.

P

Because maybe you want to change it or maybe you you go into configuration and you want to change it on the fly to be something else. So the the the person can, the person doing the actual consuming and the person doing the adding or are sometimes different, but so that that's that's the first thing. The second thing is, if you call I formatted without calling ad console, it still works, so these methods actually short shortcut and do the actual setting of the the name and the adding of the provider.

P

So you can get the best the best of both worlds. By depending on your your entry point and and and don't think of the the former name as the only way of configuring it, you can configure it in configuration.

P

So you may not have any code at all and you're only going into your config file and setting the name to something else, because you want to change between systemd and console or our one line or json.

F

But you have to add it beforehand, anyway,.

P

Yes, someone has to add it beforehand, agree so.

F

P

F

Not super working scenario, if you don't add it beforehand, it's not fully consoled based.

B

F

um Yeah, I'm just wondering because it seems we are complicating the surface quite a bit to enable this.

P

So like to just to be clear to to enable like json formatting, you call I jason and nothing else, and that was a change made from from the set of people. We got last time where you had to call like add, console and then call ad block.

P

So now, if you do call add console, then you can choose to send a name there, but if you don't call it, you can call like directly add json log console provider and that will do the the right adding of add console. So you don't have to do both calls, which makes it more complicated.

F

Is it worth renaming the method, then? uh So you don't call json console log formatter, you call json console.log, logger or json console.

P

That's fine! That's not bad.

F

Because then, like to me, after looking at this page, it seemed like I need to add, console and add a formatter for console, but what you're saying makes it way simpler and if I only have to call add system g console, it's a pretty pretty nice usage.

P

Yeah, that's good feedback.

A

So I was grabbing a drink. Did I miss anything important.

P

Yeah we we all agreed, so we could stop. Now. I'm gonna go home.

A

That seems like a good plan.

P

Oh wait: I am home hold on.

A

You're living at work now in case you didn't know.

N

So not so depressing, don't say that.

A

But it's true: we should stop staying working from home. I should stay living at work. um All right did we change anything in the apis or is that still the same.

P

Miriam, do you agree with that.

C

um With the feedback.

P

C

um Because, um if I just have so rather the feedback, I think is that, rather than add, json console log formatter, we would have add json console yep and then um so. Basically, the last three um x, the console, logger extensions apis- are just gonna. Have the log formatter at the end, remote, like it's gonna, be add, default, console log, json, console.log and add system console.log.

P

And then the the one that has the generic add console.log formatter. That would maybe be add. Actually I'm not sure what that would. That's fine.

F

But add console with formatter.

P

If you're changing the verbs changing, okay, okay, I mean whatever is fine. I don't have any strong opinions there.

A

So basically, we just formatted from the names is that what you have here, yeah.

C

Stripping log formatter from the names.

P

Wait? No! No! No yeah! Yes, exactly that. One.

C

P

C

We'll end up with uh the first five will just be add.

P

Console I do have questions about the ad console of t.

C

Yeah yeah, that's just I I was just throwing it in in case there were feedbacks on the rest of them.

A

Sorry so the one that we have so we currently have also have add console log. It takes the t form identity, option. That would also be add console, so only the last three would have log at the end.

P

So the add console log formatter, maybe should be.

C

It's adding a formatter, it's not a log, it's not actually adding up.

P

I mean it kind of is doing the same thing, the same thing that the other ones are doing. It's just more of a it's, a more verbose way of specifying the t.

C

P

You might scrolling.

C

Down because I wanted to show something, um um as with um there is a in this usages, there is one with add console log formatter.

P

Dell, further email.

C

So you're in the issue page I mean in the.

M

C

Yeah so um usage add cons, line 48, um even though we don't. As pavel said, we wouldn't use two different, add console.log formulas, but like assuming we did, um then you would also need to do add console because if it's a custom formatter you have to somehow specify the name of the formatter right.

F

C

That's why I say add: console.log formatter is not adding console, it's adding the formatter.

A

So I'm sorry, I still feel like I'm missing how the feature works like um so. What what are these new apis doing, they're, basically at a high level, they add both the the the console output logger, as well as the formatter right. Is that basically what they do yeah and then so.

P

These these lower level ones are just doing one thing in instead of doing the combined thing, so, basically, the the lower level apis, add console.log formatter are adding just the format to the system, but not turning it on, and it's basically what you use to build the other extension methods. On top of.

A

So I guess so basically what you're saying is like if I write a json console logger, then basically I would have options that are specific to how I format the json. So that's.

C

A

I have a generic for the options because it's specific to me, I have a generic for the formatter, because I'm inheriting some other formatter and where I basically you know, do the tostring, effectively yep and so the other extension methods are implemented over the one that takes t formatter and t options. Correct. That's right!.

A

And so was the idea of using a different name so that the overloads look better or what was the reason for that.

N

P

A

P

I mean it. This whole thing is a shortcut to write a console.logger with different formatting, so it doesn't seem bad to call it ad block console.

A

I mean to be honest, I don't think so. Having the same method is probably not bad, because if you actually open intellisense people will not be very likely to call them because they're paying the ass to construct.

A

But it's so I don't think people will accidentally stumble their way into these apis and then get like lost or something. um But I feel like it. It does add value to group them together because it's easier to explain in the docs if you say well, these are the building blocks for adding to the console stuff.

A

The first two are effectively just the simple ones and then from there it gets progressively more advanced right and I think, that's probably an easier story than trying to come up with some sort of convoluted naming convention where you it gets because you run out of names. But it's this java problem where everything is in manager and extension and plug-in and.

F

Question how much benefit these methods bring on top of calling ad service and calling configure with the host.

P

It does a bunch so like remember, we added overloads and we added like a bunch of methods to make it easy to write a logger provider and get change tokens. I'm sorry again, and I options that was that was that that was wired to configuration to do things like that. It does the same kind of thing. So, let's.

F

P

F

It's way more than that, okay,.

P

C

So if there's no objection with like uh the usage line 49 with 267, then I don't really see a reason to add the add console of t. I was just adding it just in case there is feedback.

P

Yeah, that's fine! I I would new the add console of t because.

C

P

Sounds good. This is for people building methods that are nicer to use. So I think it's fine to to have this. This one not be as nice.

C

Sure so line 49 to 67 is a okay example. Okay,.

P

Yeah, I mean people basically copy what we do.

A

So we keep these and we nuke this.

P

No, no, we we need the one on line. 70.

C

A

Yeah sorry, api.

C

Add console of t won't be there anymore.

A

Okay, so that means in terms of apis, we would say.

A

uh This guy is gone. Yes, these guys are getting renamed to add, console yep, and these guys stay, as is the last three without the formatter or with the formatter.

P

Without the without the log formatter.

A

So that would just be add, default console at json console and add systemd console.

P

Yeah we should, we should discuss what our default console is.

F

P

We drop one completely yeah. What is that one? I forgot.

C

uh Let's see the arguments it takes.

P

Default console.log, formatter options.

C

So if you remember um console.log formatter options is the base class and then json and default console logger options. um Just use more properties extend it.

A

I guess, but then when I would I mean why would I use this one over the regular add console that takes console logos.

I

C

Because your um your computer, if you don't have the last three years, you don't know how to you can't configure default json or systemd options. The first, the second ad console um overload, is not allowing you to configure formatter options. It's just configuring. The logger options.

F

Yeah, but for default, but for default formatter options can we just reuse the old type and.

Q

So one thing that changed is a bunch of the options on the console. Logger options got moved out into the individual formatter options. That's uh and that's uh what I think at default console would be uh configuring.

F

That's yeah, yeah um that that was the other question I was going to ask is how what what do we do about back compat? Where do we flow these old options? Do we flow them into the default console log from other options.

F

Because we would have to write for apps to keep working the same as they did.

C

So so like for backward compatibility, if, if someone is using the old usage, um if they're specifying on their console logger options, let's say include scopes and whatnot, it's gonna bubble itself down to the formatter options. If it's systemd or default, it will put it on whichever of the two. But that's just I think just in case this is just so that, but then it's still going to be deprecated um any. It's not recommended to use console, logger options, deprecated operators.

F

Are worth deprecating and then duplicating the same set of options, or maybe we should just make the new formatters use the old option types and if they need more inherit from it, I don't know I'm sorry. I wasn't here for the first review, so I may be repeating.

A

F

I think you're on.

A

To something here so like so let me ask a different question: is the motivation to have a new type purely so that we can remove the old concepts? Because then you know maybe a better option? Is you just obsolete the the things that actually don't make sense anymore?

A

Like you know uh the formatter name and the format um itself and basically leave all the other ones as is, and you just hide the ones you don't want to promote, and then you make all the new ones just inherit from the old one, because that has fewer moving pieces right. You basically don't, but if that's not what you want, then the question is: why would you not obsolete the console, like the old console, logger options in the old ad console overload?

A

That takes it because it seems weird to me to have both console logger options and default console logger options. But then everything on the old console, logger options is basically obsoleted. It seems weird.

J

I think we spent some time on this in the last meeting, which is if we obsolete console logger options. How do you specify the formatted name you need somewhere to specify which formatter is chosen, so just by virtue of that console, logger options has to remain.

A

J

A

Don't understand like I thought that the new overlords take care of that.

P

um They do but, but they actually use the the former her name option on console, console logger options.

A

So, are you saying.

L

A

Ones are implemented in terms of the old one.

J

Yeah and not not quite emo, I think when you're saying old, it's getting a little confusing yeah. The new extension methods set the formatter name on console logger options.

A

That's what I mean so by all they mean the console.logger options type as opposed, and by new I mean the default console.log formatter options.

J

Right but let's get like what we were trying to do is separate. Some concerns right. The console logger option allows you to pick which formatter is being used but actual formatting concerns like what the timestamp is or whether you include scopes go to each of the individual formatters.

F

F

um Is confusion with like two having two types now better than confusion we would have had if some loggers didn't support some options. So let's say json logger doesn't support um timestamp format and by customer system some formatting it doesn't apply. Customer is confused, but is it better than customers seeing two option types and like having the set of fields on both of them? So.

P

So emo can, can you put both option types in in view, let's scroll down a little bit, so we can see the options types.

P

So the only ones that wouldn't apply um if we kept the old one and we didn't do the new one.

C

Are you talking about lock to standard or special.

P

No, the so what we're saying, though, is imagine we just use console.log options as the base type for replace console log from other options with console logger options, just use it everywhere um as the base type and then deal with the fact that that some things are weird.

A

Yeah, I think I understand now what uh sharab was saying like it. That also explains the naming. Basically you you basically the way to think about this. You you have, you have one way to say: where does the data go and then there's another way of saying? Okay, how should the data be formatted right? That's why everything was suffixed with log formatter right, which is yeah.

C

A

Way to say this is so basis different concerns, but if you now make them extend each other, you basically blend them on the same time, but that's weird, because the type doesn't actually do any sort of formatting anymore right.

F

You don't have to inherit too right. We can just say all the options are on the old type. Formatter options have it have its own base type, but if required, they would read off, cancel other options yeah. I guess so.

J

We support that for back combat right, but it's it's weird as a pattern to have some options like something set on one options: class and something said in other options: class, because formatters are going to extend it and add more functionality right.

F

F

Have um yeah a huge opinion here, but.

J

I feel like this is the least bad, because it gives us a chance to deprecate and then get to a place where the api is clean.

A

So I have another question like what: why do we have the interaction over the formatter name to begin with, why don't we set the the options directly on the console, logger options? Right now we have a field of type console.log, formatter options that you.

C

Just said, options yeah, um because if I have a cust, if I wanna have my own custom formatter and it has a property called uh my custom property, then um okay, so then, okay, so then console.logger console.logger options would have a property and when you're exp you're you're recommending you would have a property called, let's say, formatter options.

C

What would the type be? Would it be um console log formatter options and then anyone can extend their own yeah.

A

Basically, what I'm suggesting is like it's supposed to split so like. If you look at this right, you basically have. This is basically configuring where the data goes right and then this is basically configuring how the data is formatted like why. Why would we not just change the the console logger options to effectively have properties of type formatter and formatter options, and you basically initialize the the the console logo options? You basically get to say what it looks like and what the options are right like like.

A

Why are these separated out and then then glued together by the name property? That seems somewhat odd.

P

A

So what I'm wondering is like like, if, if the so let's say your new upper console, logo options right and then there's a property of type uh console.log, formatter options and console.log formatter that you just did literally assign into these options yep like what. Why is this indirection over the formatter name like that seems like?

A

If you would just deprecate this property here, and you would say, you literally assign it into this thing here, then I don't think it's super odd that disabled colors lives on the container right like because it's like well, the concept already existed, but it's in the same place where you would do other things right.

A

It's not quite.

P

A

As a transition.

P

How do you make it work for configuration-based systems, where you re, where you set a naming configuration and have not just work like magic, magic.

A

P

Issue right like for that scenario, you really want the name as a feature.

A

Yeah, I guess I don't know enough about conflict like how does the name help you in the config.

P

So you so you put a name of the formatter and config you, you do systemdr, json or whatever name you want and then that flows that basically becomes the name of the name field here and then the system the system understands either a name set from code or from or from configuration, and it just works because we we mapped the.

C

P

Providers to the name that was here.

C

You can see a sample in the issue, page um you're in it just scroll up. If you can, you see this is like an app settings file, settings, json file and then under logging console for the uc formatter name is json right.

A

C

And then, if someone wants to set up their options right below formatter name, there's uh formatter options with inside this formatter options blob you um there could there that's where they would put their properties right and it doesn't matter um yeah. So basically, it's gonna pick up the formatter options from all the properties inside format, options.

C

And previously b, instead of formatter name, we had format and then format was the uh either json. It was either systemd or default and then right right, where you see formatter name now, we would have had those properties, but now they're, all one level deeper inside formatter options.

M

M

P

Tell you what the name isn't great, because the name doesn't really describe what what it is. So, if anything, could we somehow expose the default log formatter options as a property of the console log format as a property of the console logger options? Does that make sense? I still still keep the name, but then, like.

P

To what standard yeah built in.

P

They're all built in built-in defaults.

A

Well, I mean it's basically, so why can I not use console.log formatter options directly.

P

A

Like why do we have a default one and a base type like? Why isn't the base tab already usable as the default.

C

Right system, so so console.log formatter options um default. One also has like color properties, but then the the. But then we have, if you remember, we had default versus systemd and then systemd was simpler. It's just one liner and it doesn't have colors. So that's um I don't know how to explain, but is that is. Was that your question you're wondering why default console log formula.

J

Default is a misnomer that it's not like the is not a subset of all other formatters. It's just a particular it's what we write the console today. Okay,.

A

So then I guess okay, I know. Okay, basically, you call it text, console.log formatter options, because that's really what it is right. It's it's not json. It's text. It's.

J

Like color text.

A

Yeah and basically you can either yeah it's basically text that very colorized I don't know, quotes or something right, but like yeah, that makes sense to me, then the other. The other thing I would suggest is strip the log just call it console logger and console formatter. I think that makes more sense. Conceptually.

O

Okay question: I don't understand the text comment like a it's all text, but b like system e, that's just text as well right, it's fair.

A

Enough, I mean maybe plain I don't know like, but basically I guess what sharav was saying, I think, is the important one right. It's not like default sounds like it's. Some sort of specialized like uh like subset kind of thing when it's really it's a very particular lock format, right and right.

O

It's a default format.

A

Yeah, but I guess default is not a great name, because it kind of implies that everything else could be configured to be like the default right, because it's it's yeah, I don't know. I mean plain text.

O

A

Text would work for me, but I I I.

O

A

Yeah standard wouldn't be brad but like in in the context of console that kind of implies standard out. I guess which might not be what you want, but.

O

There's standard error as well.

C

um How about colored console log formatter options.

A

O

It has disabled colors.

C

Because it has a disable colors property, it could be called colored rather than default. Console.Log format options.

C

That's if you don't want to keep.

A

Default, let me ask you differently like like: do you expect people to use the default console log one, or do you only provide it for backwards? Compact.

J

No, we expect people to use it like it was designed because it's the easiest bars in like your inner loop, like we, we split things across multiple lines we colorize. So it is the nicest experience while working locally.

O

I mean you could.

A

O

Yeah, you could done a new mvc. This is the one it's going to use.

A

I see so I mean maybe use simple or plain then maybe.

O

J

O

J

Yeah, simple simple is fine.

E

A

And then do people like my suggestion of removing log.

A

And just call it formatter.

C

Oh okay, rather than calling it formatter yeah.

A

Basically, every time you sign up, when you say console.log, you just say console so it's like console formatter options rather than console.log formatter options.

O

Because you're in the logging namespace, it's kind of.

A

Yeah, like everything, is a log here right, but it just because you already have very long type names and the log doesn't really help you much, and I kind of like the idea that you have a console logger and a console, formatter and they're. Basically, the two independent concerns you're modeling.

J

Okay, but just just as a knit like in another world, we could have had the format to work across all logger providers. Our current implementation. These formatters are scoped specifically to the console logger.

O

Yeah console is still in the name, he's just saying: drop out: log yeah.

J

O

It would be like.

J

Json console formatter options.

A

Yes, yeah, because, basically you have two options. You basically have two ideas, but you have the console logger, which is basically controlling how it's outputted, and then you have the console formatter, which is the thing that controls what it looks like and right now. The second thing is just extended by one more term in the middle, which seems odd.

K

This doesn't make sense, yeah.

C

um May I also add um console logger options: pretty much everything gets deprecated, except for a formatter name which gets added and existing property called log to standard error threshold that doesn't get deprecated, because it's not a formatter property. It's a logger property and just wanted to point that out.

C

And you can see it in a usage as well. um I have log to standard error threshold property how it's set up. It's just basically set up the old way.

A

I see all right, so let me just do the edits that I just talked about, so we don't forget about them.

A

Yeah, that was not good.

A

P

Where is this recorded.

D

Youtube already sees it and hears it. Let me help you.

A

So I mean what I'm really thinking about this thing is, and.

M

But I'm not saying that allowed right.

M

A

Unfortunately, my suggestion is a pain in the ass to do because log is also part of logger. So I can't just replace all occurrences. So it's uh you have to go one.

J

A

O

Log formatter to formatter.

O

C

Three, that's the only so yeah so as eric said, console log, formatter options, the three of them json default and the main one we strip the log from them and then there's nothing else.

O

C

Everywhere, where we.

O

Say console.log formatter turns into console formatter yeah.

A

I guess that works yeah, editing wise. That should be what I wanted to do.

A

O

Like the interface yeah, all the options classes, any any properties.

A

And then we said default is simple:.

O

Simple and then that's the name as well right, you would in in configuration, you would say, formatter equals simple or systemd or json, or a custom.

C

Right, yes, okay,.

A

That works, so we would say default is simple and then the enum would also, I guess, the enum. We can't change right, because the enum already exists.

O

The name is deprecated.

C

Yeah, the enum is deprecated, it exists as either default or systemd.

A

Yeah that works and then.

C

um When we remove the add console t overload, um because we didn't need that.

A

Okay, so I think I have made all the changes now, let's go back to the methods then like do we make any changes to the method names.

F

Yeah we decided to drop work for matter right of the.

J

F

K

F

K

F

At default becomes that simple.

A

So what I'm thinking is, maybe we should drop the word console from them and replace it with formatters. It would be add simple, formatter adjacent formatter, add system deformator.

J

Well, no, well not. We can't do that because it actually hangs off the logging builder. So it's unclear that it's for console specifically.

A

I see, then that would probably still go with like console formatter right because it like, if you want to promote that this is the difference between the console and the console format. I think that makes the most sense then.

F

But they also add the console logger right. It's enough to call add json console log formatter to get console logging with the right format. uh You don't have to call add console in addition to that and having like having the current naming makes you think that you need to go both and you don't.

A

F

It should be okay,.

K

F

A

Simple console.json console at systemd console that makes the most sense right.

E

P

But the add class log formatter itself that one doesn't add the actual um that one doesn't set the format her name so maybe.

C

And the log threshold it doesn't set the log threshold.

N

C

Property lock threshold, it's called under their threshold.

A

um Okay, so the one that takes the formatter and so the t format entity option should be renamed to something else. Then.

P

No, I think, add, console block formatter for that one. It's fine, because it's a super low level api that never used by anyone besides people authoring extension messages that that hide. That method.

A

Yeah, that makes sense to me, so we would so that's what I'm asking so basically so the so. The first two will be add console because they already exist. Then we, the third.

P

A

Yeah, the third one dies, and then we name the next two add console log formatter.

C

A

The last ones are add simple, console adjacent console, add systemd console all right. That makes sense to.

A

Me yeah the the console formatter api, like the right one is still a bit like takes a lot of options. Oh, it shows a lot of parameters, but I also don't know what to do with that.

C

The right one yeah.

A

Like I mean, if you scroll all the way like there's a there's quite a bit of stuff going on there right.

C

There, the reason is: uh uh logger.log already takes all of these arguments, except for maybe the text writer.

N

C

And then I I tried um uh removing the scope provider, but then I think I think.

P

C

A

So I guess yeah I.

F

Mean I don't know considering how complicated the interface is. Should it be an abstract class, so we can add stuff to it later.

L

A

I mean that one I mean the other option we have is, instead of doing that, you could just take all the arguments and put them in a struct or something because the thing is, if you already take, you know six arguments, it's not unreasonable to say at some point: you want a seventh or an eighth right, and so, if you basically have a method that takes parameters directly, you can't add to that right and the abstract base type doesn't really help you much because then the right one is virtual and then you would add a new virtual overload.

A

Then you have to like plump the state through somehow, so you might be better off, just saying, take a parameter object and then, if you want to add more state to it, well you just add to that guy, and then everybody already gets that state.

P

So it could be a strut. This truck has to be generic because long is generic. um That seems fine. If we want to do that. Log log entry.

A

P

There, a read only type.

O

A

That would work for me.

O

Does the writer go on it or do you take the log entry and then the writer.

F

I wouldn't put the writer there, because this this sounds like something that would be reused in logging more and more by itself. Yeah. I would, I would think about it as what, if we, instead of having right of the headers tracked in the main eye, logger interface,.

P

Yeah, you still want t, though, so you can avoid allocations.

F

P

That's one issue, but.

N

What is the reason to not make it an abstract class.

P

No, no, we can yeah if you want, if you really want it krista. I.

N

P

You have to act nicely.

N

All right david can, can we have enough shot class? I really like that.

P

Absolutely but it won't have anything, but as long as you agree with what help here, I will.

A

Yeah so to like, I, I think to me. The abstract task is kind of like orthogonal to this right concern right, because if you agree, if you want to add one more thing to it, like an abstract base, type has very similar issues where you would have to add a new write overload. That is also virtual. Now everybody who overrides the old one still gets the old behavior, so plumbing new state through might not be as easy as. Oh, you have a struct, and you add one more property to that.

A

Struct and everybody already gets that.

N

I agree with vemma yeah.

A

And again, every time you see a method that takes six arguments or seven like you want you, it seems like a grab bag already right.

P

Yeah it's kind of over the top okay. So let's add a log entry start.

A

Okay, let me try to.

P

Only struck that's generic log entry of t.

A

Public read only log entry.

A

Does it have to be that doesn't have to be prefixed with console, probably right? No.

P

O

O

But it's going into the console breath assembly, though.

P

uh Good question good question: excellent question, very good question: no.

F

P

Abstractions, I think it should go into the yeah into abstractions. Okay, because I could see us using default interface methods haha much to your chagrin, to add an overload of log in theory that that basically unwraps this struck and calls the other overload.

P

In 2027 and everyone's comfortable.

A

You're such an optimist, david.

N

P

A

So I mean: why is the assembly a hard question? I mean it would go in the same assembly wherever the interface goes right.

P

Well, because we think this thing is more generic and it could be used by the log, the log contract itself.

P

So in theory, we wanted to go close to the actual other logging stuff and it could be used here as well in the console specific like assembly, but it should be in the general abstractions assembly.

A

So what does it take then? So, basically, what basically all the parameters we have log level category event id state uh exception, exception.

P

Formatter scope, provider and text.

A

P

Not scope, no so it wouldn't say scope, letter and and text writer, just the ones before the.

A

I see and then scope, provider and text writer would still be passed to it. Yeah.

F

Should we put scope.

P

Provider on it, so no like in theory. This thing could be either be a property or it could be um di injected. But we run into some issues because it has to be plumbed basically everywhere via the factory, so it has to come in via the factory.

P

um Then the factory passes it to the provider to the logger, so it gets kind of odd if, if the factory doesn't own the providers, because you need the same instance between the if we put it in di, it has to be the same instance that is resolved by the factory um that is consumed by the formatter itself.

F

Okay, I'll take no yeah.

P

Yeah we tried plumbing and it just got hard.

F

I believe it was hard the first time.

A

Okay, so at this point I made enough edits that I probably should update things, so we can look at the same thing.

A

Because my brain can only handle so much.

A

All right, so here are my edits. uh Hopefully this all looks familiar to people.

P

What is it called simple.

A

That's simple:.

P

A

That's what we said right.

P

Interesting cool cool cool cool cool cool.

A

And then we have our read: only structure, block entry.

P

With set fields, what kind of compiler is this yeah sorry.

E

P

A

Well, that's the other questions like does it actually make sense as a read-only extract.

N

A

Well, but I guess and then you would have construct okay, you can probably overload the constructor right. I guess that's fair, but like still a pain in the ass, then.

G

I mean a read-only truck's allowed to have settable properties, they just can't be auto properties and they can't have side effects.

E

H

Like like is this: is this wrapping a a class, and then these are just forwarding to the class? What class, where what is log entry of t-state wrapping, something where the setters actually have some some reasonable side effect.

P

There should be no set, it should just be a plain old data structure that can't be that can't be changed.

E

L

E

P

E

P

A

I'm I'm not good at uh compiling in my head, apparently.

H

Oh, is this using the admit, only feature.

P

K

Have a language.

G

P

This is interesting like entry of t, I like it, it's not bad.

M

I have my moments.

P

Oh, should that be, should I be possibly in because this this thing is so huge: it's like a bajillion fields.

A

Well, if you're passing them as individual parameters or you pass them as one giant struct, doesn't make a huge difference right.

D

Is that true it it if it's passed as one struct, it will be a mem copy, rather than necessarily a copy. Well, actually, in this case it will be a copy of each individual field, because there's.

P

Types yeah make it make it in make it efficient.

D

Yeah, if it's in it will at least pass a reference to the existing field and the parent struct. And since it's read only there, there won't be any copies.

A

So wasn't there like, I don't I mean I don't care one way, the other I just like, but last time we proposed that somebody said they were proof implications by do making it in as well.

P

For big stress, it's always good right, like I, I think the size was. There was some size threshold that they'll be agreed on, for when we would use in.

D

The there's both a size threshold and a concern for uh if the struct is mutable, um if it's mutable, then you may incur hidden copies and if it's small enough, then you're, you may be prohibiting an optimization where it gets passed in registers um aliasing or something like that.

D

P

D

On linux, a a struct with two ends will be passed in uh in two registers, rather than being passed by reference. Yeah.

G

The the guidelines as written uh are don't have a structs, that's bigger than 24 bytes. That's public and don't have api, that's public that takes variables by in oh cool. Let's keep it then.

A

So then, what I'm hearing is this yep? I guess.

O

Dropped read only you dropped read only on, though.

G

Is the struct already bigger than 24 bytes.

F

G

Then it should be a class.

D

G

Also for json apis, which are explicitly.

D

Performance oriented to avoid all allocations. Yes,.

A

G

A

Jeremy you're, not making friends here.

G

Yeah, I said the rules as written are no structs bigger than 24 bytes and that are public and no public api that takes anything by in, but.

H

I thought they were, they were frameworks.

G

Is because we say no big trucks but they're they're.

H

Guidelines, not rules right.

G

That's why I'm reminding of where there was a question of like? Wasn't there a problem described before and I'm.

H

Reminded of what.

G

The guidelines say.

H

D

I own half the types that are over 20, I own half the structs that are over 24 bytes and jason owns the other half.

H

Well, once this library's finished now you'll own one tenth.

G

Of them, if it is yeah as a read-only as a read-only struct, if if we want to pass it by in because this is the once, you start down the path of breaking guidelines or deciding guidelines, don't apply in this situation like in might be better, or I mean it would be perf better if it's a read-only struct.

P

Yeah pathway in right.

G

P

G

If your final implementation is just going to unpack it and flat call, this is passing it as destruct anyway.

G

What passing a struct and passing by flat parameter calls is exactly the same performance characteristic like that's how it passes struck by value it just flat copies.

D

That's entirely dependent on whether the struct is only a value types or if it contains reference types. If it's only.

C

D

Types, it will actually use mem copy which might do a 7d block copy under the covers versus an individual field copy um right, but it has.

G

Reference type, so it's it has both right should be the same as it should. If I understood when yawn explained it to me of the big rules that got dropped down to simple things in the guidelines, it was uh it's essentially a flat the same as if it was expanded to individual parameters in a method call so.

P

Just to be clear that this has both both reference and value types as as fields and properties.

P

Right event, id is destruct t, stick can be a structure or int.

L

P

But if it has any left.

L

Correct me, if I'm wrong number, if it has any reference, any reference fields, it'll be copied field by field.

D

The the only requirement is for reference types is that the reference fields be copied field by field, so the gc stays in sync, the if t state happens to be a large struct that is blittable that will be copied by cmdblock.

D

uh Likewise, if you have a large sequence of blittable fields following each other, those could be cindy block copied. It's not required that they be individually copied. So.

L

We should design we should design for what's allowed, but I'm curious: what do we do today? Do we actually do we do do we do just copy the single string field and then blit everything else.

D

uh So there's actually three fields that are reference types here.

L

But there's the exception and there's the string. Okay, so do we if t straight was a large struct would be blitted.

D

uh T state, if it was a large blittable struct, would be blitted as an individual field. I see.

L

What about would we copy event id and t state together, or would we do those individually.

D

uh I I believe we will for certain scenarios, but not this one.

H

Well, we can. We can make that improvement in the future. Though, like we don't right, I think that's what you were saying right steve we can. We can design for yeah.

L

We should decide right, which is not what's allowed, rather than what we do today.

G

um Wait if I understood um one of the ons, I think it was codis that I had this conversation with essentially or my understanding is on linux. We don't do anything clever at all with passing strucks by value. It just expands them into fields and passes them one after another. In the register allocators at least it.

D

Depends on the struggle? No that's true. The the the the system v abi for certain structs allows them to be passed in multiple registers.

D

uh If otherwise, it will be passed by reference if it can't fit into two registers or if it's not a hva or hfa, which gets even more complicated scenarios. Likewise, if you have more than five parameters on system v anything past, the fifth parameter will always be passed by reference because it won't fit into one of the available argument. Passing registers.

G

Okay, okay: this is just how we came up with 24 bytes. If he's like four ins and two longs are very different and uh four ins and eight shorts are very different and hand wave call it 24, bytes and move on so yeah.

D

24 is about the upper bounds of what will be acceptable, there's, of course, exceptions and special rules, and most of them get into numerix areas. That's not applicable here.

A

Yeah all right so then I'll be happy with what we see right now.

P

No, I I super, don't understand what what yeah! Why is there? No in.

A

I thought I just did it in.

P

O

Also, I thought I console formatter becomes an abstract base class to make christoph happy.

E

A

That is also a thing that we talked about. Yes, so then it would be public partial class.

A

Console formatter, I guess abstract.

A

A

So my first question is.

A

Should should the console should the console formatter actually extend.

A

So where is the I guess we don't have a public formatter for simple right. We only have the options that are public right, never mind.

A

A

All right, so it is abstract.

A

O

Else can you fix the in.

A

Yeah, I've made the thing abstract. The method is public, abstract virtual now I.

P

Have to ask again, why is it called simple console like why simple what simple mean like single line console or is this? Why simple.

A

Well, that was basically what we said. The default is bad because it kind of implies a subset, and then we basically said the only thing we can think of is simple, because nobody like text, okay,.

O

Do you have better names, dave david.

K

P

No, that's fine! I I won't even try.

O

So by default you get the simple console, formatter right, if you don't specify anything, you just say, add, console and don't configure anything, that's the one you get.

L

Sorry, can we go back to log entry for a second, I have a question on the end thing.

G

L

We said in for right, but what about the funk.

O

That funk is something different.

L

But it gets past the t-state.

N

It does actually.

L

Now we're up to creating a custom delegate type.

D

Well, what I I don't to be clear, I don't think t state should be passed as in you've got no clue whether t state um is actually a struct. You've got no clue whether it like it could be just be an int, in which case passing by n is worse. It could also be a mutable struct, in which case passing by n is worse.

L

Right but the argument for log entry being in was that t-state could be big.

D

Well, it itself is also big enough that it's likely always going to be worth worth.

L

Yeah and with the all the other overhead involved here,.

D

Well, the the there is no other overhead for passing my in long.

L

Entry is something the overhead involved in calling console format or not right.

P

D virtualized because it will be it'll, be a base class and all the derivation version will be sealed right.

E

So we'll be able.

P

To make stuff up at this point.

D

It it depends um basically, the way it works is log. Entry is big enough that it will always be passed by reference anyways.

D

If you don't pass it by in then it will be passed by shadow copy, which basically means the jit will create a space copy, the existing value to that new space and then pass a reference to that new space to the new method.

D

uh So passing by in given it's a read-only struct, given that it's always going to be over, uh you know 24 bytes. In this case it's always going to be at least 32. Bytes means that it will always be beneficial to pass by in.

E

A

Yeah, I was under the impression that the primary reason we made it in is because the size of lock entry, I'm new, that this is all big state. I thought that I would normally assume that t-state is an object for the most.

P

Well, most common case, yes, but we do have a few structs that we use to avoid the allocation, but there are other overheads um in general.

A

But for the structs like, what do you have in them? Like I mean they, they probably are not bigger than 24 bytes right.

P

No they're very small.

A

Yeah, in which case.

P

It is probably not some have more fields.

H

Is there ever a scenario where t-state would be a class and just the same instance gets reused for multiple calls to the logger, or is that just too dangerous that is doable, but.

P

Dangerous-Ish, we do tell loggers that you shouldn't you shouldn't store t-state anywhere. That's why console like turns into a string before storing it in the queue? um Because, if the caller that does want to reuse the object, then they can.

H

It is that I mean, but is it a recommendation to callers that they are free to reuse the objects if they so desire? Yes, okay, so callers can actually pool them to cut down on uh to to improve performance if they wish. Okay,.

L

Sorry pool what levi the t.

H

L

H

Themselves, if they are large objects yeah, so that that means, then that t state could be passed by value and everything would be just fine, because you would just pass a reusable class over and over again right.

P

I mean that's the intent I super hope. Bloggers aren't storing the these date, be really bad for everyone else.

A

I mean what would be the point right because you have to pay for the for the two string anyway, you might as well. Do it early.

H

F

H

That kind of that kind of follows our guidance with things like read-only memo char as well like you shouldn't, really hold on to it after you return, because.

I

H

Could be reusing the buffer yep.

O

Okay, I have a less important question on abstract string name like should it just be a regular property and the constructor take the name or abstract property.

P

What, if you want to compute a lazy name? No, I actually have no idea.

O

P

Compute, a lazy name right because that it needs to go.

O

A

Also, like you have like four instances in the entire process right so.

P

Whoa whoa: that's a lot.

A

Yeah, I'm not sure.

O

I mean just in general, what do we, what do we generally.

A

So I mean making it a constructor is kind, so it kind of depends on how you want to run this right. If, if you want name to always be there making it a constructor parameter is probably slightly like. It basically forces everybody to pass it in kind of thing right, which is a bit annoying when you derive from the type, but but.

F

Does it also focus it to be constant, which is what we want.

C

Is that going to be a problem with di.

P

No so like it, it isn't a problem per se, because you would basically force everyone to do right and not pass in the name. So you pass the name to base yourself and then your constructor, you take other arguments that aren't the name so you're forced to specify name when you call the base, um but it shouldn't affect di. If you, if you didn't, want someone to make, if you want to make your own base class and then have someone provide the name, then that's that's the issue that they have to solve.

P

But but it shouldn't be an issue.

A

Yeah, I I mean I guess in that case it probably makes more sense to actually have a constructor parameter. I guess pablo said it kind of forces it. It's immutable right, yep.

A

L

Whatever assembly, this in hasn't been nullable annotated, yet right.

O

Right all of extensions is like net standard tool.

O

And I just want to call out the the log entry of t is going in a different ref assembly.

J

O

Like I don't know how we say that.

A

Yeah, so that's my general pet peeve that we have stopped paying attention to for almost all new features. Now so like I, we need to get back into the mode where we think about the assemblies that we put stuff in um normally. We just put it uh like. We just broke it into different code sections and said this is assembly a disassembly b.

O

So it definitely shouldn't go in the namespace console.

C

We'll be logging, the abstraction right abstraction.

O

Yeah and the logging namespace.

A

So it should be in the same name space as the console.logger extensions.

O

Yep but a different assembly.

A

G

We already have a console sub namespace in microsoft: extensions logging, yes yeah.

L

That doesn't conflict at all in normal usage with system.console. It does.

A

G

A

No, it shouldn't the.

G

If you're inside microsoft, extensions logging, because now that is found as a sub name, space of your current scope,.

E

G

System right, yeah, yeah.

P

K

If you're working on it but.

P

K

Yeah, so when I use extensions I mean like if I want to write line in the console, I have to say console.writeline yeah I mean like you know. The system is.

P

Like yeah, so that should only really affect you if you added the namespace and we basically put everything for the most part in the main namespace for extension methods. So you only put in for options which is a little bit unfortunate, but.

G

Well, I mean the only people who would be affected are people who are working inside the namespace logging for the most part or in another sub name, space of logging, because then console will be better, we'll have a better match against the sub name, space of your or your parents, name space than it will for system that name space from your global using.

G

So it's just us basically like right.

I

G

Was just funny because this morning someone posted an issue of like enum methods, don't work anymore and I'm like well, you have a sub namespace in your current namespace called enum and that's what it's finding instead of the type and he's like. Oh language, closed issue.

A

All right so, which assembly is the existing console.log extension stuff in.

P

The console assembly- yes, but.

C

P

But the namespace is yeah, I mean yeah, that's right.

A

So this would be, uh what does it say: microsoft, logging extensions console.

A

A

And then the log entry thingy would go in what assembly? What else is in there.

A

Somebody difference between.

O

Logging abstractions and just straight up logging logging has implementation in it.

P

Let me let me explain the intent of these split layering things so like originally, when we were doing like assembly interfaces and all this stuff. We had a split between abstractions and implementations, with the intent being that you share this package, as if you wanted to implement logging or provider, you would use the abstractions and it contains abstract, abstract-based classes interfaces enums everything required to implement a provider, but you don't need the implementations, and then we had an implementation in in kind of a uh we had implementation assemblies that would implement the spec.

P

Basically, um so throughout our stack, there's a pattern of like abstractions and implementation assemblies.

O

P

O

So, like configuration is the same same.

P

O

A

All right happy with that.

F

L

What's the typical expected usage of log entry, like you, pass something for all six arguments to the constructor.

P

Yeah, I think the the thing that is.

O

P

Infrastructure.

O

Is going to create the log entry and then people who are making their own formatters would get it and consume right. But.

A

How do I log like, like how would I write a you know basically equivalent of console.writeline? What would I do in order to get stuff into the logging system.

P

A

P

I logger.log log information passing a string in.

A

P

It turned into a cult a lot with a bunch of arguments.

A

So I asked for an eye logger and the logger basically is what calls into the infrastructure that constructs the log entry.

L

A

Okay, so then that case, I don't care.

L

So we expose the constructor, because why not someone may care, but in general we don't expect anyone other than us to use it right.

C

Or whomever is implementing their own custom formatter.

P

They they don't create it though they consume. It.

A

Well, they might do it for tests right, yeah.

P

Q

P

A

It works right, so then we have five minutes left. Is there anything else we need to do or should we take a look at this one, or should we postpone this one here.

K

A

M

K

M

O

There was one there's add console log formatter like are we still cool with the log formatter part in there yeah.

A

This one here yeah this one. I thought we said it's infrastructure right. We don't expect yeah, like I guess.

F

These guys are, we dropped log from everywhere. It's just console for matter everywhere else.

P

Oh, the log is gone, but we keep from either.

F

Oh yeah yeah, so it.

A

P

F

Console formatter.

A

O

And then just to make sure on the color stuff we're totally cool with ansi console codes, telling people if you want to make color in your formatter, write, ansi, console codes and then we'll strip them out. If we need to on windows and turn it into set foreground color set background color.

L

We're going to parse all the strings coming in and look for things that look like antsy color codes.

K

Super easy all right if the mode of the vt mode is not enabled.

L

On the console.

O

K

We will do that.

O

Which should only be for down level windows so like windows,.

K

O

Windows: 8., yes, can we detect that.

A

O

Yeah, there's a there's, an os api, you can ask, do you, do you support ansi and if, when that's turned on, we should just be able to forward it straight through on windows.

K

Windows, app, get console mode watches and you can't test yeah.

O

And I saw let's.

P

O

I

Say: windows 7.

O

And windows 8, we just don't get color anymore.

L

What are we going to do for like right now? We disable the color apis on linux, for example, when you're redirected. What are we going to do in that case.

A

So when we talk to the terminal guys last week, the the general consensus was you don't want to do that because it highly depends on other things, whether it makes sense or not. So, for example, when you do get log, it's redirected to less and less still shows colors right. So like it's it's basically, the general pattern is: if you really want to suppress the colors like there's either like command line switches, you pass to the thing or something else, but you can't make the decision necessarily in infrastructure automatically.

L

We added that in the first place, because it was spamming, people's log files and it was causing massive beatability issues.

A

O

Kind of the difference here is like this is a console logging right like if you wanted to do some other kind of logging like um serialog or something like that's a whole different formatting.

L

Yeah right, but people some people never redirect from the processes that are using this.

O

No, they probably do. I guess.

A

Yeah, that was the thing that I also asked like. It seems to me, like uh that's a general problem on linux or any system where you have effectively and the escapes is the only way to write color, because it's unclear to me how you would do that. But.

L

I guess the whole issue open about this and the fact that we lack the ability to specify from the cli down whether it.

G

L

G

L

I feel like before we dig ourselves a deeper hole. We need an answer for what that story is going to be. I.

O

L

O

We have an options like if you don't want it right, you can put in your configuration, disable colors and then and then the formatter shouldn't be written colors anymore.

A

I mean that would be my my my quick thing. The problem with configuration.

L

Is it's not convenient when you say disable colors equals true? Well, that's that causes the implementation to remove any antsy colors that were written yeah.

O

Right, the formatter, the formatter, the simple console formatter- will not put antsy colors into them. Oh.

L

No, but what if, what if the caller is putting in colors there's no.

B

H

L

Writes like the color string for red or blue or whatever.

O

I meant like the custom formatter like the idea. The whole idea with this opening up the formatter logger is that a third party can write their own formatter and if they wanted colors in their formatting, they would write anti-colors in.

L

O

L

Calling I logger dot log string should not be passing in ansi codes.

O

Right! No! Yes, exactly.

P

O

Because it could be going to serialog or database or something like that.

O

That's correct.

A

Yeah the number one goal that we had- we just we just didn't- want to have colors being also part of the abstraction of the formatter right, because that would that would make it complicated right. So we said that the implementers, basically they want to write colors. They would do what simple console formatter options. Do they basically expose an option for that, whether they have colors or not?

A

Maybe there's also more configuration options like what color you're using and stuff like that, and then they basically just write it formatted, like nc, escaped to the underlying logic infrastructure, and then we do nothing with it. We just output it directly to the console unless we're running on windows 7, in which case we filter it out.

O

Well, we filter it out and then change the color using apis, or we just take them out all together. Yeah.

A

That's something we can decide. I think uh I I think, I'm okay with saying you don't get colors at all. I mean it's already hard enough.

P

That'll be a change I think, for the for the implementation we do right now we don't try to interpret the acid codes, but we do not put them in the string if we, if we, um if you turn colors off and then we can see if we can fit the whole like parsley, acid color thing, because I think that's the big piece of code to write right so to interpret and then use the color apis in dot it to write the string.

O

Today, internally, we have a windows, a windows console and a non windows console, and then we passed the system console colors around.

K

O

Right and we didn't want to expose any of that.

B

O

um The console api, so you will get callers today on windows 7.. Do we have a parser like in parse with pt100.

P

We have to write one right, so I I would say like I would do that part last basically say like there's a regression in windows: 7, you won't get colors and then we try to fit that last piece in after we get this checked in in the right shape.

C

P

If it no, no, if, if that is a lot of code, is all well.

C

P

Or not, oh awesome, then: okay, cool, we're done.

L

No, but I just want to make sure I I understand so if I set disable colors to true that's controlling whether our implementation generates color codes or not, and then in our implementation of something when on windows, seven or eight we, if that is, uh if somebody else has generated the color codes, we will remove them. If that is true, did I understand that correctly.

A

L

It's so, I think, there's.

A

There's two sides here right.

L

Sorry, that's if that's false, uh that's yeah! If that's false, then on windows, seven or eight, we will strip them strip out the one. When do we strip them out? So basically,.

C

So so, if I may uh call, when you have console formatter and then uh the console formatter.right uh whomever is writing ilogger.log, they just uh the the message they write doesn't include antsy, colors or anything right and then uh console formatter dot right internally. What happens is that it first embeds, antsy, colors and then parses them out, so that so.

L

Why is it, why is the same component both adding and removing that's what I'm not understanding.

O

It it's not the same component, different components.

L

So what are the two components.

P

There's a consumer that kind of defuse strings and writes to the console and does it produce it actually produces those strings.

L

Okay and and they're they're who's. The producer in this case, like what class on the screen, is producing that.

O

The formatter itself anything derived from console formatter right.

L

Okay and what's consuming it.

P

The console log processor, I think.

L

Which is an internal.

P

L

And so, but the simple console formatter options so that controls one of the possible formatters one.

G

L

Possible producers, but not all of the possible producers, is that the issue.

P

I don't really understand when, when we would remove myself.

A

O

If, if you're running on windows, 7- and somebody has an app that uses the system, the simple console formatter and they didn't set disable colored or whichever way it disables that color it's false. If it's on, if colors are on yep right, so we're on windows 7 and we told the simple console formatter, you should be producing colors the system, simple console formatter is going to be injecting antsy color codes into the string.

A

No, but that won't be controlled right.

L

We have a stream of data coming between a uh arbitrary producers and a consumer and we're using the ansi codes as sort of injected into the stream to tell the back end when it should be doing its color setting. If it implicitly supports those ansi codes, then it just lets them pass through. If it doesn't, then it removes them and maybe translates them into something else.

L

A

So but like the thing is, like you know, the the simple console log formatter, sorry, the simple console formatter we control correct so like on wind, seven, we're not obligated to use the the the nc escape, but we could literally just say you know if you are running on win seven or lower. Even if you set colors to true I'm not going to emit them because we can't filter them out yet so we don't have to just let them through right. So, like I think.

O

Behavior right today, that is.

K

O

Turned on on windows: 7, you get colors right.

A

But that one we could also do right, because we control that implementation right.

O

No, why not, unless we have the ansi parsing on the back end.

L

This is how they're proposing doing that email they're, proposing doing that by injecting the codes on the producer and stripping them out and reinterpreting them in the consumer, because it's asynchronous it's the right, sir, isn't able to call set color like you know, console dot, set color right. I see a reset color, because the color would reset by the time it's processed.

A

Yeah, so I guess the the.

L

Place where the formatter happens.

A

In the place where the uh where the actual output is being done is too far away, I guess that makes sense, but then I would say so like as a starting point. I think regressing on all the platforms is not that insane. In my opinion, like that, that, like I mean it, might not be ideal, but as a starting point, that seems reasonable until we have a parser okay, I mean.

O

We can still say I mean I think, to.

A

Me, the bigger issue with the parser is more like for other console formatters right. If somebody has their own custom thing either they have to do the the thing that we do, or they basically just always emit nc escapes, and it's up for us to do the right thing, but.

C

Isn't it the purpose of having the text writer in the right call that later in system console, we would have the set background set foreground apis or like.

A

Yes, we would have that, but the problem is like the. It depends on how the data is flown right. So if the data is flown as a string and then later on is actually output to the console, like you, don't have a convenient place to replace the nc escape emitting to the you know, set the console, color codes and windows right. You would have to reinterpret that data. At that point,.

O

At least that's more efficient.

A

O

I mean it's not going to be a string. It's going to be a buffer right, yes, text writer is going to write to a buffer and then give that.

C

O

C

Other thread yes, actually.

O

Right to the console so yeah, it's just a question of: are you parsing that buffer and then stripping these out and setting the right thing which.

A

By the way, I don't think it's that bad, because that's what windows does on windows 10 and up like if you actually write console to that they do the emulation for you so like so. It's not like you know. We would be the first ones doing that.

P

So I I prefer that that seems easier.

L

Sorry, what is what is that.

P

um To interpret the the bytes and the set the console color like whatever, but but I don't get why we'd have to strip ever, I feel like if no one's producing it. When would you have to strip that what.

A

Are you stripping.

P

Sorry is shipping interpreting.

A

No stripping would be in the case where you say globally. I want to have to turn them off right and so like. Basically, if, let's say my fancy, emote formatter doesn't have a disabled, colors property, and so I always emit ncs case, but then somebody wants to say I want to redirect this output into something readable, please strip them. I think it's, it's not unreasonable for us to like, if you already do the parsing to have a global turn of all colors thing, that is, a command line, switch or something right.

A

J

The global turn off wasn't something proposed right when we were talking about stepping up until now, we meant interpreting.

I

J

A

Sure all I'm saying is that, like interpreting could mean don't do anything right so like in that case it's kind of part of the same I mean if you parse them already you all you have to do is not call look, call the console.

J

Api all on the same page here that we're not doing like a global turn off switch or anything like that.

L

As part of this feature,.

J

L

Yes, all right, yeah.

J

I just I just I'm.

L

Highlighting that there there was a pretty active thread in dotnet runtime about a desire to control at the cli level, whether colors are or are not emitted.

A

You mean generically for any app or specifically for asp.net logging for any app.

P

A

A

So that would mean that if we wanted to do something strippy, then that would not even be in the logging infrastructure. That would be literally at the low level where we actually write to the console.

L

Well, it depends on whether you're talking about stripping or whether you're talking about generating in the first place so generating.

G

L

If we were just talking about system.console right, system.console doesn't doesn't like on, redirect, doesn't dislike work by writing and then stripping out the color codes. It just doesn't generate them in the first place right. So if we're just talking about system.console, there wouldn't be any stripping it would, it would just not generate them when it shouldn't be generating them, and it would generate them when it should.

A

Yeah, so there's this other problem that we have, though right which is like if we, if we were to support modern colors with console right, meaning, you know 255 colors,.

C

A

The 16 that we have, we would basically have to have some facility that generates ansi escapes right and then the problem is whatever. That thing does that you know at that point, you normally get stripping for free right.

L

I'm I didn't follow that I mean you could have a design where, rather than calling console., you know, foreground color equals old enum. You have console.set newhenum and it does whatever it needs to internally to generate the right codes or not.

A

Sure but like, but I think I guess if we were to support them, we would like to also support them in arbitrary strings as well right for cases like the logging infrastructure, for example. That's the desire that we want to have.

L

Maybe I I'm just saying that there are multiple designs possible.

O

There's other consumers of this as well like we've talked to other teams like powershell, wants to start doing both emitting and parsing antsy control.

A

Yeah, I guess the high level thing is like whatever we do for console is not part of this feature, and it's orthogonal right like we can either do something like what stephen suggested or what I'm thinking but like at the end of the day. It's just a completely different design that it sits on top of console.

L

I'm saying it's not orthogonal if you end up with a global switch like that.

A

Then you lost me like what do you mean by if you end up with a global switch like that, the cli.

L

Adds a flag that allows you to specify whether you want color or not.

K

But at that at some point it would be implementation details I mean like if we later we got this flag in the logger I mean we can handle it right.

A

Well, I don't think we would ever support an arbitrary command line, switch for any app right. I think the best you would do is you would say whatever command, I'm parsing, you do. You can accept the flag and then call the console api that says strip colors or something right like I have a hard time, imagining that we would pre-process the command line before we give it to user code. That seems weird.

L

A

L

Request was specifically about the cli dot net run.

A

Oh, you mean dot net itself. Well, that's a different thing.

O

Exe the host, like.

L

No build space run space. My app.dll no color.

A

Right I mean that one that one I buy more. That's basically that's what I asked like for any console app or for for asp.net, but what you mean is like literally for the dot net, tooling cli right, um yes and yeah that one I because.

L

That feature exists on rust that exists on go. It exists on wherever else.

A

Right, yeah, that's what I meant earlier like it's, typically, that it's the it's the user's problem to solve right! It's you you're, not necessarily.

L

In this case, it's.

A

Not the user's problem.

O

It would only work for developers, though right, like dotnet run, is only for developers, so it wouldn't work. When I publish my app and then give it to somebody sure now now there would be no more dash dash, no color.

L

Well then, it ends up being an environment. Variable, that's read by the core system.

O

So now that's something different than the cli right like it would be.

L

No, not necessarily like this. My point is this: whole thing needs to be designed because likely, what would happen is the cli ends up setting that environment variable or app context switch or whatever it ends up being and that's respected by the core system, and then, uh like my point, is my concern: is we were developing like an individual component without having designed what the whole experience is? That's all I'm saying.

O

I 100 agree there like that's why this part's hard and I wanted to talk about it.

K

But I expect some other people is already doing, that I mean it's not it doesn't have to be our libraries but other apps or others and libraries I mean non-microsoft. Libraries is doing that. I mean like parsing or or formatting the vt 100, and they will end up with the same situation anyway right it doesn't matter what we are going to design at the end.

A

Well, I guess I mean depends on what you mean by this and that right, like I mean so, this is one argument here which says we have this feature here. Where we talk about logging in the construct of asp.net and or I should say in the context of microsoft, extensions and whether you can suppress colors or not right, and then there is the orthogonal thing which is, you know, can I turn off colors entirely, for you know the net tooling experience which would now probably require some low level plumbing in console that this interacts with.

A

If you assert this feature exists, then probably you would design this feature here slightly different by saying: oh, we don't actually do our own stuff, we just plug into console and do the right thing there, and I think that's that argument I buy the question is: what would be? What would we do differently in this feature?

A

Would we basically just say we don't care about colors right now because I don't think that's really an option because we already have colors in the system that exists today right so now, the question is: if we make formatting optional like how do we deal with colors and what's the.

O

Most, the only thing we would change it wouldn't be any api. The only thing we would change would be. We wouldn't do the parsing on the back end.

A

But I thought that's already said we don't do any processing today we would just regress on wind seven and call it if.

O

We didn't do any parsing. If we didn't do any parsing and the formatter starts. Writing ansi console codes. Yeah. Then it's just on windows, 7 you're, going to get the ansi console code, no.

A

That's what I'm saying we would just not do that, but we would basically say in the implementation of our simple console formatter we would say if we run on win10 or up, we use nc escape. Otherwise we just don't emit them, no matter whether you disable colors or not,.

O

A

O

Custom one, if there's a custom one, we just tell you that's a bug in your stuff. You should go check to see if you're, yes,.

A

Because they don't exist today right, so it's not a regression. Somebody would have to implement a new formatter and do their own ncscapes. There right and people.

O

Just the regression is our simple one won't be showing colors on windows 7.. That's.

A

Correct, that's what I said like I thought: that's what we were leaning, because that basically means we don't have to do any parsing today we would just say if wind7 we don't emit colors. Otherwise, we honor the disabled, colors thing and emit nc escapes or not.

K

So what happens if somebody disables the vt mode in the.

A

K

A

uh They'd, so in that case I would say yeah so the way we would set. We basically did my so we wouldn't check for win7. What we would check for is is, are the other virtual terminal codes enabled for the console session you're in or not okay,.

K

So you is generally about checking the call as a movement.

O

Is this an okay behavior like is it can asp.net accept that difference.

J

I I don't know why we're going on about the regression and behavior, because I think miriam said she has an implementation for parsing it already. So I think it's this I feel like this is a moot point. This conversation we only use like four chords right now background and foreground color set reset. I think at least, to functionally support. Our current behavior is straightforward.

K

That's the question is like: are you parsing everything or just passing for.

H

K

H

I mean this would be.

K

The question I raised because, like vt supports many things: it's not just a resource right, so.

J

Yes, I get that I think it's it to get to parity with what we had thus far that what our formatters do is pretty straightforward. Supporting the entire extended vt control cords may be a bit of a challenge.

A

Yeah I mean like the good news, is vt really isn't a super well defined thing right? It's this. You know loosely defined spec that people adhere to right, but in that sense it's always somewhat hand-wavy and if you say we only do background and foreground colors, I don't think that's entirely unreasonable, like my bigger concern with these kind of things is that we have a prototyping implementation but like how hardened is that like? Are we sure that it performs well I'll? Be sure that we, you know, don't accidentally?

A

Have you know, issues really parsing correctly and then I'll put garbage like? Are we willing to put up that stuff on our implementation, for what amounts to basically supporting people and all the operating systems like it seems like we go out of our way to make the experience good there, which is generally not what we do right like it's, not that we specifically went over all the way to any other colors for win7. We just got it for free by implementation, happenstance, right and all the implementation changes, and now it's actually a cost to maintain.

A

So that's why I personally think it's a starting point to say we don't give you colors on win7 like if you want to have the best experience you have to be on the latest operating system and if somebody complains we can, then you know do the proper thing. But you know, as derek said, the proper thing will probably be more than just foregone and background colors right and and then we wouldn't actually design the end to end. For that.

O

But as long as is it supports what we have like our existing behavior, let's imagine we can. We can keep our existing behavior and yes, if you're doing other things, maybe then with a custom formatter. Then maybe junk gets printed to the console right on.

Q

O

7 that doesn't seem terrible right, like you could never do this before yeah. So it's not like it's not like we're taking away behavior.

C

For the very least, the parser would just uh parse the background for foreground, the ones that it already supported um before this change and then reset color and that's it and then it would skip any other nc code. I mean sorry any other um facilities.

L

C

L

Only kick in if you were running on windows, 7 or windows, 8.

O

80 exactly or you turned it off and if you, if you're on windows, 10 and and.

C

You turn off 18.

O

L

Sorry, no, I and you turned off the the os setting correct so.

A

We should we should verify this. My understanding is, if you like, on, if you're on wind 10, that had support for vt code, you don't have to do that because they do that, for you.

O

Correct I've verified it myself, I'm on windows 10. I just started out putting ansi codes and in old school cmd. It's like here's, some colors for you.

A

Yeah, so they do the translation, basically right, so so that means basically, the parser is only kicking out for low for for for older platforms, which seems fine, like I mean, let me put this way like I personally, don't care so much. I would not go to my to turn it off either, but I was just pointing out that there is an extra cost that we take on and, generally speaking, whenever we talk about parsing.

A

That is not super trivial to get right right and like usually, we want to bake these things and all I'm asking is like. Are we willing to to take this on like? If engineering team feels happy about the implementation they have, and we are thinking it's rock solid enough to ship it then yeah. I would not go to my way to kill it right. um I would not just jump to the conclusion that we need to have it because we happen to have colors before.

O

It feels like sarah's got a different opinion.

O

Is that truth rob or do you agree? I.

J

I mean, I think I I'd say this is a engineering concern like I'm. I have the same opinion as emo. It depends on what the cost is and whether the engineering team is okay. Supporting this going forward.

J

Maybe my misunderstanding was supporting. The subset of functionality should be like that. We have already today should be straightforward, and I would push for that, but it comes down to whether you guys want to maintain the code for this.

A

Yeah, what I'm hearing is engineering seems to be happy with it, in which case yeah. I.

C

A

Go down my way to remove the code that would be backwards too. Yeah.

K

The other thing also I'm expecting later I mean sooner or later we are going to have some some apis for parsing and formatting vte 100. So at that time we can just switch calling the cpi's and- and there will not be.

J

Any cost in the.

K

Future right, yeah.

J

F

J

F

Sorry uh there.

J

Is another option.

F

Outside of parsing the buffers you can sneak in a custom text, writer implementation, that's internal and only our simple formatter knows about, and you can still use the old set, colors method on it.

F

If we only want to fix the simple formatter, we can make an internal thing for it to work that would be entirely contained in the console assembly. That's just a question of.

L

Where the parser lives right.

F

But there is no need to have a parser. Imagine you had internal console text writer that had set foreground color and set background.

A

Yeah color think that's.

F

A

That we talked about earlier is that the problem is at the point where you call the text writer you're not physically attached to the console, because it goes in some queue and then that queue actually later on puts it to the console. So basically the people producing it can't set colors. Yet.

F

But we own both sides right for the simple formatter we own, both the producer and consumer. So we can have an internal text writer implementation that they both know about and like we sneak.

C

That's what is happening inside in the implementation.

L

You're just saying, rather than writing, rather than using nc escape codes as tokens use something else as tokens.

C

Even that could work.

F

No just call um like add more apis to the text writer that would.

A

But I guess the problem is you.

F

Have store information.

A

F

A

O

F

A

Where you store data.

F

In the queue we already have it like console logger current current implementation have the key like that that stores, colors and stuff.

A

Oh interesting and like how do you store it then, like you store it as a like, literally.

F

O

Before and why we moved to textwriter.

C

Exactly we had that in the previous review.

A

Yeah, I guess that one is something that we can do, though, right because, as travel said like, if you already have an implementation that basically buffers that, then it's just a basically a private handshake between implementation of the simple console, formatter and the back end, and given that we control both ends. That does not seem completely insane right like it doesn't have to be part of the public api because they can trivially downcast. The text. Writer to you, know our internal text, writer with awareness or whatever right, and that's just an internal implementation detail.

A

It doesn't be part of the public api.

L

Maybe I'm I mean we're in implementation, detailed territory now, but maybe I'm misunderstanding, my understanding was the reason that things were being proposed. The way they were was because we wanted a single uh basically by stream handoff between the producers and consumers. If I'm understanding correctly, this would add a dedicated second one is that true.

A

So my understanding was that basically we said we want to use ncaa escapes to avoid the problem that the formatters have to somehow take spans in order to format colors at all. We basically said like no, it's a the contract between the formatters is just the text writer and if they.

L

Want to have colors they do that, so that that becomes the one communication mechanism. What I thought bubble was um suggesting was in addition to that mechanism. You have a second dedicated one for the legacy or for the for the simple console which still uses spans and colors attached to it.

A

Right but understanding, what's what dm was the implementation, because we currently have that implementation already? Apparently that's how the culture that's.

L

What the current system works, I'm saying that what he's suggesting is basically for all of the new stuff. You have the new scheme for the old thing. You have the old scheme. So now you have two instead of one. Yes,.

F

No, but it both falls into the yeah true, but it all flows into the old scheme based thing in the end.

A

Well, it wouldn't right like because we wouldn't we wouldn't parse the output from the new system and then create spans out of that we will just win a bunch of them as text. Yes,.

J

Yeah so for new stuff, you just use a regular text. Writer for old stuff. We use the existing implementation.

L

But the cons there there's one consumer or two consumers.

J

They're two different consumers right. There is uh right so.

L

That's what I'm saying like that, the the suggestion is to have two consumers instead of one.

C

I think uh if it's implementation detail, I can share my share the shared after the call, and as so long as it doesn't affect the api proposed right.

A

Yeah I mean to me it's more like that's what I was asking earlier like. Would the api change in any meaningful way here like it seems we will still support the existing mechanism, which had a way to disable colors, and currently we only have colors effectively in one place, and the only thing that we change here is basically to say if the json console, formatter or the or any other formatters want to emit colors. They do so by embedding nc escapes.

C

How about to simplify it and rather than having a disabled colors property on simple console? Formatter options remain. That would remain on console logger options. So um if disable callers is false, then we kind of regress whatever I mean not necessarily regress, it's just. If it's disabled, then no parsing happens. Anyways.

L

I I have a unix question that does potentially impact the api, or maybe it won't so system.console goes out of its way to use whatever ansi escape codes. The current terminal says are the right ones to use, so it parses the term info file for the current terminal and uses that language to compute the right strings to output for given colors.

L

This isn't going to do that. Presumably, does every terminal also respect whatever ansi escape codes? This is going to use.

A

So I don't know enough about what, so what does the term infrastruct tell you like? How would they esc, how do the escape codes for foreground color differ?.

L

It tells you it gives you a basically, it uses this kind of language where it basically specifies a string, and you give it the color value and it computes the ansi escape code to be used for that term. For that terminal,.

A

Interesting so my understanding and I could be wrong but like, but what I've heard so far is that they're standardized, for you know this. This color code is this. Is this sequence? I wasn't the way that they would differ between different implementations of of the terminal.

K

My understanding, vt 100, is the minimum I mean like minimum set that is supported across the board and what what stephen is is talking about. I think it's it's something like.

E

You can enhance.

L

K

If you want to support like 24 pet colors or something like this, so this is my understanding. We can confirm that I mean, like you know whatever I mean like the simplest case for vt 100 for foreground background colors is, is always supported.

O

Today, when you're, not on windows, it just hard codes escape 40m 41m, whatever.

L

Right- and I guess I'm just- I just want to make sure that we're not going to end up on certain terminals and maybe it's a legacy concern. Maybe it doesn't matter with any terminal that anyone actually uses. I just want to make sure we're not going to spam it with control quotes. It doesn't understand.

O

If we did, we would we would be doing that today.

A

Existing yeah I mean so the other question I have is so like, echoing what mariam proposed or what I thought she proposed. What if we moved the disabled colors to the console, formatter options base type and allow any formatter to honor that so that, if I write my own json console formatter, that is colors, I can just query the the property that is part of my own custom, struct or my own custom class, and then we can say, like everybody should should.

A

Basically, you know check this thing to to emit colors and we would basically say like yeah. If somebody wants to turn them off, that's how you would turn them off for everybody. There's always a disabled, colors property on every on on every formatter.

J

So the the only weird thing about that is today formatters, don't need to consume, console logger options like we do it for our stuff to preserve that compact. But if I was writing a new formatter, I wouldn't consume console logger options, and this is now like no.

A

No, I'm not saying constant logo option saying comments.

J

I think you can format it.

A

So we have something so on our simple one: we have disabled colors right and I'm basically asking should we just move this property to the base type to this guy here, so that every formatter always has a way to suppress colors.

O

Oh, even the other two that we have, that don't do colors yeah.

A

C

A

C

So it's basically in effect, trying to say, skip parsing right.

A

Well, basically, what it says that yeah, don't put them in the first place right.

C

Yeah, let's get parsing and don't even yeah encode them embed them.

K

But if we have escape parsing means that if it is false, so this means that we are going to parse all the time.

A

Well, I mean that there could be a configuration option somewhere else right, whether we do the stripping this way or not. Right, I guess, in a perfect world, we wouldn't just always run the the stripper right. That would be pretty basic.

K

To have the colors in the in the nails I mean because, like you know, we are talking about colors only here I mean like if we are talking about escapes, so it will be more than that. I mean it's not just colors, so we have to be specific about what we are going to parse.

A

Yeah, I guess my general assumption is that, like a formatter would not put an arbitrary on the escapes right, like you know, move carrot left move, carry it up. That seems pretty useless in a formatter right. What you would normally do is like colors, and you know formatting, like the you know, bold italics underline whatever they support in vt right, but that's kind of the extent to which you would expect the formatter to use nc escapes right like what else would you do like.

K

If I'm running on windows 10 and I'm sure that I'm running windows 10- and I can't put anything in the in the stream- it doesn't have to be just colors and I will be pretty sure that this will be rendered correctly. So because it's not good person.

K

So I I I don't know about like what bible is going to do. I mean in general about why producing this text writer I mean with the codes inside.

A

Yeah, I guess my imagination isn't strong enough, but like what like, besides colors and, like you know, bold under italics, what else would you put in there like? Would you move the cursor like.

K

It seems oh there's something.

A

K

Font, for example, I believe so there is some other controls. I mean like it's not for the colors, but I I don't remember exactly the details now, but there is more than the colors okay.

J

I think the only thing I can think of is like line fields and move cursors.

A

Yeah, that's what I'm thinking and that seems generally an interactive mode sensible, but it doesn't make a lot of sense when you effectively produce the lock asynchronously and then I'll put it later. But that seems fairly weird to do these things.

J

But is the so the the premise of this question is: are you unhappy with the name like color.

A

Yeah, I think what he's saying is more, like you know, disable nz escapes or something like that. Right.

J

My vote here would be to keep like disabled colors because it captures like 90 something percent of the use case. I.

B

C

So then it would be just an extra thing that says disable. um What's it called like skip parser or something it would be something on its own, not related to disabled.

J

I think we're proposing not having like skip parsing just use. Disable colors is the is the option. Okay,.

A

Well, I guess yeah I mean to me skip parsing is kind of like you control what happens at the base here. Basically, what we are proposing is you, you change what people put into the pipe right so, instead of us parsing them out, you basically tell everybody, don't put them in the first place. If you do it's a bug on your end,.

A

Which, I think is fair right, I mean like it seems, generally bad to do work, and then uh you know us being on the hook to remove it later right. That seems weird.

O

We can turn it off in ours. It's right.

A

Well, we'll just basically what we currently have well, we basically have disabled colors only in hours, and the question is: should we just make this a general purpose feature, so anybody could do that.

J

I mean the the simple answer: is we have three reference implementations of formatters and only one out of three uses them yeah.

A

L

J

Make a good case to go into the base.

A

Well, I mean, like my question is like: why does the john like? Why does the json console formatter not use colors? It seems like when you emit jason. It would be not insane to actually have that render nicely on the screen. No.

A

Like I mean, maybe we don't do the work now, but I mean that seems like a fairly reasonable feature, because if you would like to do eventually.

E

A

Am I like making things up now.

J

So I think I'm extrapolating a little bit here, but the primary use for colors is when people look at the console like both with json and system d, they aren't meant to be human, readable formats, they're meant to be machine, readable formats, so that, like you, know you plug them into some other logging system. So colors are usually not like that valuable. There.

A

Fair enough.

A

I guess the downside is, if you don't, if you, if you put it in the base and the verse that can happen, is it doesn't apply, but everybody will use the same property physically right. If you don't put it in the base, then you basically ask everybody who does colors just follow the pattern right, which is not bad, but it's just that's kind of what happens right and people will probably not do. That it'd be my guess.

J

I'm I don't have a strong opinion on this. I defer to hearing on what president is.

A

Yeah, but I I I do get a sense that we may be over engineering at this point like it seems like what we currently have on screen, like basically captures what we need to ship and then everything else is kind of speculation. On our end.

C

So it's good to go.

A

Like I am personally fine with it like it's a, I think we have enough of the discussion happening with colors, that I think we clarified the behavior that we want, and uh so my understanding for behavior that we want this- that we will basically say uh we will, on our end either use the the parser that you currently have on win7, um or we would just tell people like to disable the colors by default, or we will do it manually right.

A

But these are the two options that we have and it's kind of up for the engineering team to decide whether you're happy with the with the strip that you have for win7. And if you feel like you're happy with that, then it's okay to say, yep. The only thing you handle is what we currently put in from our end, which is foreground and background color, and that's the only thing we handle.

O

Sounds good so out of the box on win7, simple console, formatter, that's printing out colors! Do I see colors on the screen.

J

Because it stands right now: yes,.

K

Okay, yes yeah, we shouldn't break the compatibility.

K

J

I I should add one thing: the reason I'm a little watered because I don't think it's just windows 7. There are a lot of places where they're embedded consoles that I don't know the behavior of like the output window and bs or the you know. The f5 window, vs launches the embedded, console and vs4 I'd be worried if all those common targets actually support nc consoles, which is why I'm hesitant to lose the functionality.

A

So my understanding from talking to uh um what's.

C

His name rich, was.

A

That the the the only other implementation that we have of the terminal is vs code, because in vs the terminal implementation is baked by the actual terminal that we have in windows. Okay,.

C

A

Should support that already so then the only other thing is the the vs code, one and he said like they basically supported ncs case, because that's kind of the only thing that makes sense for them. um So I think it really boils down to cmd and yeah cmd effectively on windows. Okay,.

O

So I take back what I said before you have to put it a registry setting for cmd to print out colors for from ansi codes.

O

Yeah, you see arrow open bracket, 31m.

A

J

I guess that seals it for us.

A

So sorry, which operating system are you on you're on wind, seven.

O

I'm on latest windows, 10. my winver says: windows 10 os build 19.41.

A

Yes, because you have to set the you, have to basically call the windows api that that enables vt-100 right in the process.

K

The owner of the console said that it's turned on by default. I believe on windows.

O

K

O

Okay- maybe maybe it was just because I upgraded from from before and not a brand new install, I guess, but it wasn't on on my machine, I had to enable a registry setting yeah.

A

So minor setting is a registry setting basic controls. What the default is for processes you spin up in cmd but like if, like in the process in that you basically can set the cert. You know what is it set terminal mode or whatever, and you can set terminal. You know vt 100, enabled or something right, and if you set this in cmd, it should do the right thing and my understanding was that sorry, what who's going to do it.

O

We would tell the user to do that as well.

A

Well, I mean we could we control the process right? We would be what you would call that.

L

A

Yeah well part of the initialization of of the logging infrastructure would do that.

J

I thought it when you launched the terminal itself.

A

By the app it's not called by the operating system like you are supposed to call that, if you want to enable it like it's, basically the app that decides that.

K

But should we take this decision on behalf of the users I mean like I, I don't think this is wise to do.

K

I mean like it's up to the user, to turn it on or off, but not for us. I mean to to force the direction for them.

K

Yeah I mean like the best we can do just we can check the mode well.

A

I mean like so to give some context right if you launch a process in the new terminal today on windows 10 and they will set the mode by default. Already, that's.

K

Right yeah, so like the question.

A

Is if you, if your process now gets launched in cmd, I don't think it's unreasonable if we set it by default in modern.net, and then, if you don't want this, we give you an opt-out from doing that, but it seems like like. Why? Would you not want to do that like realistically, what I understood from rich is the only kind of applications that don't want to have that are some sort of legacy, applications that have some weird legacy: behavior, where the output of the console is parsed by some crazy.

A

You know thing that is super sensitive for stuff and that's generally.

L

Not the case, if an app sets it is it automatically undone when that app goes away.

A

Well, it's basically a setting just for your own app. It does nothing to do with the process.

L

Hey, I don't understand it's not configuring.

A

It's basically a setting for you, that's basically a process level setting right. So if your process dies, you didn't do anything to the terminal. It's just the setting of your own app.

O

That's it so then, even if I have the registry settings saying I don't want this, we would automatically just overwrite it and say nope. You want this.

A

Well, the setting doesn't disable it right. The the the setting is basically controlling what you get by default. That's my understanding, but it's not a disable. This behavior, it's kind of like in cmd, is this mode on by default or and if the setting is absent, then it's not on by default right.

O

A

I think this is.

O

Not a logging question, I think this is a higher level. I.

A

Would agree with that, but like it's basically like the question is, if you build a modern app like what should be same defaults right.

O

Does the registry key default to off.

A

O

Yeah, if it's not there,.

A

O

My machine, if it's not there, you don't you get the ansi console code printed out, not the color.

I

And if they add a key there, can they set it to off explicitly in a way that we could check.

L

Can I suggest that someone just follows up with windows to find out exactly yeah.

A

That's something like you should. We should talk to the traveler guys because, based on what they said us last time like basically the recommendation is, you should do it by default. The only reason they don't do it in windows is because they break super old apps, which I don't think applies to us.

I

I think it's okay to have an opinion here. We should turn it off.

J

Looking at the docks for set console mode, it is sticky, though it's not tight. Your process lifetime.

A

So you're saying you're literally changing what the process like the terminal itself.

J

Yeah, it's just like setting a color like a color will persist after your, like application, has gone away right like if you change the foreground, color you're stuck with it.

A

Okay, maybe I'm wrong, but my understanding was that so let's say one process launches in cmd sets this terminal mode and then adds like access and the next process starts. I don't think that that flag is on for the next process, but you're saying it is.

J

That's what my reading of it is. I could be wrong now. I I I will take it as an action item to follow up. Okay,.

M

J

We will enable if it if it's kosher, let's say that's the.

A

Yeah, so so just to be clear that the the the terminal already and windows has that opinion right if you launch anything from the new wt terminal, it's on by default for every process, so like it's only when you launch a process in cmd where that's actually kicking in.

A

So like that's. Why that's why? Basically, by which said you should turn it on, because the only case where you want to run an existing app in that environment is because well, this is some sort of like as400 interrupt thingy that just doesn't work otherwise, but like that's generally, not the case for any app written in the last 15 years.

A

So, like that's, why? I think the idea is, we should probably take an opinion here and just make that the default.

K

Yeah, I agree if we provide also a comfort switch with that I mean just by default. We set the mode ourselves and if somebody.

A

K

This behavior, so they can turn into.

A

Yeah I mean like that's something we should probably talk to the windows guys. My understanding was that the desire or the need for this should be so low that it might not even be worth it um like, for example, in in windows terminal. I don't think you get to turn it off ever like windows terminal only works this way. So that's why I'm not sure that we need to support that either.

A

So anyway, but like that's, probably something I thought that we should follow up with so like who's taking point on that is that mariam sure up? Okay, you have all the contacts right, yeah, cool, all right, anything else, then, or can we just say this is the api we have.

F

O

We can disable colors down on simple right.

A

So, okay, can somebody summarize now what behavior we agreed on so they.

O

I mean, are we, do we have what's on the screen.

A

uh Yes, that's why I'm sending right.

O

Okay, so disable color stays on simple formatter.

A

J

And then so, the apis on the screen and from an implementation side will enable uh like vt parsing on the windows terminal. Assuming the windows team like recommends it, and there are no other side effects.

K

I think we do the parsing only if we, if we don't if we are not running on the vt mode in the cons. That's it right. Yes,.

A

Yeah, so my understanding is from talking to riches if you're on wind10 and you basically don't have the terminal emulation, enabled they will filter out the codes and set the colors to the old system and everything else they basically drop on the floor.

O

Yeah, okay, so it's kind of two: it's two decisions. One is in the console logging when the terminal isn't set to parse ansi we'll do the parsing of antsy and change the colors and then there's an orthogonal question of whether we just turn that on by default on brand new dot net 5 apps.

A

Yes, so, like that's, maybe very misspoke, I think my understanding from from which was, if you're on wind 10. You should never do any parsing yourself, because even if it's off they do it for you. So the only so the only area where you would have to do any processing yourself, because the the terminal can't handle vt100 is basically when what is it when it, when eight or lower or something right.

O

So what you said before is not true like on my machine. I have it turned off, I run a console. It shows me the ansi control colors in cmd.

K

A

Okay, then, let's basically make it maybe the other way around. So what behavior do we want? Because we basically the behavior we want. I think what I heard was on win7 you get colors, you don't get nc codes spilled to the console right right.

O

O

J

E

O

When you're, when, when your terminal ansi is turned off, you still get colors right.

O

Yes, because that's what you got before.

J

The only question is an implementation side on wind10, whether we use the same windows, 7 path or we set the console mode and use the.

O

Nc coordinates yeah, I think that'll be an implementation detail. This is behavior. What behavior do we want? Yeah.

A

O

Behavior is turned somehow somebody turned it off. We still get colors.

F

Right, we should okay.

O

And then there's the orthogonal question of should.net5 exes just enable it by default.

O

N

O

K

Was the last one.

O

Should.Net5, when you run an exe, should it.

C

O

On terminal parse and see by default, and then that's a follow-up question for the windows team on like: is it sticky, past your process, etc?.

K

Yep, this exchange should be on the level of the console, our console itself or.

O

K

In the logging only.

O

It wouldn't be, I I don't think, that's a logging decision. I think that should be. That should be an all up like if you run a.net 5 app, should it turn it on or not so, even if I'm not using extensions logging, if I start stuffing ansi console codes to the console, should it start turning into colors.

K

Okay, so yeah we should. We should turn it on on the level of the console itself.

O

The console or the host or somewhere somewhere.

I

O

Microsoft, extensions somewhere lower. Yes, if we're going to do it, it should be for everywhere, yeah.

A

Sounds good all right, so basically the four things is then we said implementers of I console. Formatter should use vt100 for color decisions on wind7. We still want to show colors, not vt100, escape sequences on windows. 10 plus we want to see colors, not vt 100 escape sequences, even the vt100 processing is off and then there's the last one, which is should.net 5 by default, enable vt100 processing all right. So I think that captures everything we set. Then.

A

And then I can mark this api. Finally, as approved.

L

If there is a decision made that dot net 5 should uh set that mode, I think that goes beyond this library like that needs to be. Yes,.

O

A

O

A

O

A

So who's, who takes point for making a separate issue for that.

J

I'll file a separate issue and then I'll capture, something in the dot net designs. Repo, sorry.

A

What is your github and user account.

J

uh S h, I r h a t t. I.

A

S h, I I oh here we go yeah here we go.

A

Perfect all right- and I think, we're good to go for today.

K

uh Emma when we review all the other things.

A

Sorry, what are the other things.

K

Yeah the item it was in this agenda today, but it's.

A

The improved activity api so like yeah, I would find a separate thing for this one here.

K

I have in my there is a design review at three o'clock today.

A

There is one, but that's for networking.

K

That's right for.

A

Gprc, like the reason I set it up for the afternoon, was because of uh james newton king because he lives in new zealand.

K

A

So I don't think we'll have time for this one. I.

K

Will follow up with you offline.

A

Yes- and tomorrow is off so it will be next week, regardless.

K

Yeah yeah sure all.

A

I