Metrics APIs Additions

[tarekgh]

Fixes#77514

[ghost]

Note regarding the new-api-needs-documentation label:

This serves as a reminder for when your PR is modifying a ref *.cs file and adding/modifying public APIs, please make sure the API implementation in the src *.cs file is documented with triple slash comments, so the PR reviewers can sign off that change.

[stephentoub]

Weren't we going to use a subclassed Meter who's exposed Dispose was a nop?

[tarekgh]

I will investigate the disposal issue further to determine the best possible solution. I'll track the issue and will link it here.

[stephentoub]

Ok. If we don't end up changing this, we need to change the name of the method. Calling it Create and returning something that's IDisposable but then telling people in docs not to Dispose it will lead to a pit of failure.

[tarekgh]

I opened #86592

[stephentoub]

The consumer could do:

((List<...>)meter.Tags).Add(...);

Would that mess anything up?

[tarekgh]

Users doing that will be missing up with themselves. It is not good to depend on the internal implementation anyway. But even if they do that in this case, it will not cause crashes or terrible things. Will just be updating a list that not supposed to be mutated.

[noahfalk]

mostly looked good, a few comments inline

[noahfalk]

Oh I missed this. At some point in the past I thought there was an explicit RecordObservableInstrument() API. Doing it this way feels weird to me because now GetMeasurements() is mutating the list every time it is called. I think the design would be better if we have a separate explicit API that records observable instruments. For example imagine a user wants to capture measurements at several points, then verify them:

//arrangeusingrecorder=newInstrumentRecorder<int>(observableInstrument);//actSetState1();recorder.GetMeasurements();SetState2();recorder.GetMeasurements();SetState3();recorder.GetMeasurements();//assert//I want to confirm that all three cases produced a measurement.//but I can't use GetMeasurements() here because it changes the count to 4.Assert.Equals(3,recorder.GetMeasurements().Length);

Users could of course workaround it by saving a snapshot of the measurements earlier, but needing to treat the API differently for observable and non-observable instruments feels awkward. Having API called 'GetXXX' change the thing it is getting also seems like it wouldn't align with our naming rules.

[tarekgh]

I'll keep whatever I have in this PR and then we can talk about this one to know if we really need a new API.

[noahfalk]

Any reason to use List rather than array? We should never modify this collection in the future. Also I'd suggest we sort it.

[tarekgh]

I changed the List to Array. I'll address the tags sorting and tags insensitive comparisons in a separate PR when addressing #86614.

[tarekgh]

Fixes#77514

[ghost]

Note regarding the new-api-needs-documentation label:

This serves as a reminder for when your PR is modifying a ref *.cs file and adding/modifying public APIs, please make sure the API implementation in the src *.cs file is documented with triple slash comments, so the PR reviewers can sign off that change.

[stephentoub]

Weren't we going to use a subclassed Meter who's exposed Dispose was a nop?

[tarekgh]

I will investigate the disposal issue further to determine the best possible solution. I'll track the issue and will link it here.

[stephentoub]

Ok. If we don't end up changing this, we need to change the name of the method. Calling it Create and returning something that's IDisposable but then telling people in docs not to Dispose it will lead to a pit of failure.

[tarekgh]

I opened #86592

[stephentoub]

The consumer could do:

((List<...>)meter.Tags).Add(...);

Would that mess anything up?

[tarekgh]

Users doing that will be missing up with themselves. It is not good to depend on the internal implementation anyway. But even if they do that in this case, it will not cause crashes or terrible things. Will just be updating a list that not supposed to be mutated.

[noahfalk]

mostly looked good, a few comments inline

[noahfalk]

Oh I missed this. At some point in the past I thought there was an explicit RecordObservableInstrument() API. Doing it this way feels weird to me because now GetMeasurements() is mutating the list every time it is called. I think the design would be better if we have a separate explicit API that records observable instruments. For example imagine a user wants to capture measurements at several points, then verify them:

//arrangeusingrecorder=newInstrumentRecorder<int>(observableInstrument);//actSetState1();recorder.GetMeasurements();SetState2();recorder.GetMeasurements();SetState3();recorder.GetMeasurements();//assert//I want to confirm that all three cases produced a measurement.//but I can't use GetMeasurements() here because it changes the count to 4.Assert.Equals(3,recorder.GetMeasurements().Length);

Users could of course workaround it by saving a snapshot of the measurements earlier, but needing to treat the API differently for observable and non-observable instruments feels awkward. Having API called 'GetXXX' change the thing it is getting also seems like it wouldn't align with our naming rules.

[tarekgh]

I'll keep whatever I have in this PR and then we can talk about this one to know if we really need a new API.

[noahfalk]

Any reason to use List rather than array? We should never modify this collection in the future. Also I'd suggest we sort it.

[tarekgh]

I changed the List to Array. I'll address the tags sorting and tags insensitive comparisons in a separate PR when addressing #86614.

[tarekgh]

Fixes#77514

[ghost]

Note regarding the new-api-needs-documentation label:

This serves as a reminder for when your PR is modifying a ref *.cs file and adding/modifying public APIs, please make sure the API implementation in the src *.cs file is documented with triple slash comments, so the PR reviewers can sign off that change.

[stephentoub]

Weren't we going to use a subclassed Meter who's exposed Dispose was a nop?

[tarekgh]

I will investigate the disposal issue further to determine the best possible solution. I'll track the issue and will link it here.

[stephentoub]

Ok. If we don't end up changing this, we need to change the name of the method. Calling it Create and returning something that's IDisposable but then telling people in docs not to Dispose it will lead to a pit of failure.

[tarekgh]

I opened #86592

[stephentoub]

The consumer could do:

((List<...>)meter.Tags).Add(...);

Would that mess anything up?

[tarekgh]

Users doing that will be missing up with themselves. It is not good to depend on the internal implementation anyway. But even if they do that in this case, it will not cause crashes or terrible things. Will just be updating a list that not supposed to be mutated.

[noahfalk]

mostly looked good, a few comments inline

[noahfalk]

Oh I missed this. At some point in the past I thought there was an explicit RecordObservableInstrument() API. Doing it this way feels weird to me because now GetMeasurements() is mutating the list every time it is called. I think the design would be better if we have a separate explicit API that records observable instruments. For example imagine a user wants to capture measurements at several points, then verify them:

//arrangeusingrecorder=newInstrumentRecorder<int>(observableInstrument);//actSetState1();recorder.GetMeasurements();SetState2();recorder.GetMeasurements();SetState3();recorder.GetMeasurements();//assert//I want to confirm that all three cases produced a measurement.//but I can't use GetMeasurements() here because it changes the count to 4.Assert.Equals(3,recorder.GetMeasurements().Length);

Users could of course workaround it by saving a snapshot of the measurements earlier, but needing to treat the API differently for observable and non-observable instruments feels awkward. Having API called 'GetXXX' change the thing it is getting also seems like it wouldn't align with our naming rules.

[tarekgh]

I'll keep whatever I have in this PR and then we can talk about this one to know if we really need a new API.

[noahfalk]

Any reason to use List rather than array? We should never modify this collection in the future. Also I'd suggest we sort it.

[tarekgh]

I changed the List to Array. I'll address the tags sorting and tags insensitive comparisons in a separate PR when addressing #86614.

[tarekgh]

Fixes#77514

[ghost]

Note regarding the new-api-needs-documentation label:

This serves as a reminder for when your PR is modifying a ref *.cs file and adding/modifying public APIs, please make sure the API implementation in the src *.cs file is documented with triple slash comments, so the PR reviewers can sign off that change.

[stephentoub]

Weren't we going to use a subclassed Meter who's exposed Dispose was a nop?

[tarekgh]

I will investigate the disposal issue further to determine the best possible solution. I'll track the issue and will link it here.

[stephentoub]

Ok. If we don't end up changing this, we need to change the name of the method. Calling it Create and returning something that's IDisposable but then telling people in docs not to Dispose it will lead to a pit of failure.

[tarekgh]

I opened #86592

[stephentoub]

The consumer could do:

((List<...>)meter.Tags).Add(...);

Would that mess anything up?

[tarekgh]

Users doing that will be missing up with themselves. It is not good to depend on the internal implementation anyway. But even if they do that in this case, it will not cause crashes or terrible things. Will just be updating a list that not supposed to be mutated.

[noahfalk]

mostly looked good, a few comments inline

[noahfalk]

Oh I missed this. At some point in the past I thought there was an explicit RecordObservableInstrument() API. Doing it this way feels weird to me because now GetMeasurements() is mutating the list every time it is called. I think the design would be better if we have a separate explicit API that records observable instruments. For example imagine a user wants to capture measurements at several points, then verify them:

//arrangeusingrecorder=newInstrumentRecorder<int>(observableInstrument);//actSetState1();recorder.GetMeasurements();SetState2();recorder.GetMeasurements();SetState3();recorder.GetMeasurements();//assert//I want to confirm that all three cases produced a measurement.//but I can't use GetMeasurements() here because it changes the count to 4.Assert.Equals(3,recorder.GetMeasurements().Length);

Users could of course workaround it by saving a snapshot of the measurements earlier, but needing to treat the API differently for observable and non-observable instruments feels awkward. Having API called 'GetXXX' change the thing it is getting also seems like it wouldn't align with our naming rules.

[tarekgh]

I'll keep whatever I have in this PR and then we can talk about this one to know if we really need a new API.

[noahfalk]

Any reason to use List rather than array? We should never modify this collection in the future. Also I'd suggest we sort it.

[tarekgh]

I changed the List to Array. I'll address the tags sorting and tags insensitive comparisons in a separate PR when addressing #86614.

[tarekgh]

Fixes#77514

[ghost]

Note regarding the new-api-needs-documentation label:

This serves as a reminder for when your PR is modifying a ref *.cs file and adding/modifying public APIs, please make sure the API implementation in the src *.cs file is documented with triple slash comments, so the PR reviewers can sign off that change.

[stephentoub]

Weren't we going to use a subclassed Meter who's exposed Dispose was a nop?

[tarekgh]

I will investigate the disposal issue further to determine the best possible solution. I'll track the issue and will link it here.

[stephentoub]

Ok. If we don't end up changing this, we need to change the name of the method. Calling it Create and returning something that's IDisposable but then telling people in docs not to Dispose it will lead to a pit of failure.

[tarekgh]

I opened #86592

[stephentoub]

The consumer could do:

((List<...>)meter.Tags).Add(...);

Would that mess anything up?

[tarekgh]

Users doing that will be missing up with themselves. It is not good to depend on the internal implementation anyway. But even if they do that in this case, it will not cause crashes or terrible things. Will just be updating a list that not supposed to be mutated.

[noahfalk]

mostly looked good, a few comments inline

[noahfalk]

Oh I missed this. At some point in the past I thought there was an explicit RecordObservableInstrument() API. Doing it this way feels weird to me because now GetMeasurements() is mutating the list every time it is called. I think the design would be better if we have a separate explicit API that records observable instruments. For example imagine a user wants to capture measurements at several points, then verify them:

//arrangeusingrecorder=newInstrumentRecorder<int>(observableInstrument);//actSetState1();recorder.GetMeasurements();SetState2();recorder.GetMeasurements();SetState3();recorder.GetMeasurements();//assert//I want to confirm that all three cases produced a measurement.//but I can't use GetMeasurements() here because it changes the count to 4.Assert.Equals(3,recorder.GetMeasurements().Length);

Users could of course workaround it by saving a snapshot of the measurements earlier, but needing to treat the API differently for observable and non-observable instruments feels awkward. Having API called 'GetXXX' change the thing it is getting also seems like it wouldn't align with our naming rules.

[tarekgh]

I'll keep whatever I have in this PR and then we can talk about this one to know if we really need a new API.

[noahfalk]

Any reason to use List rather than array? We should never modify this collection in the future. Also I'd suggest we sort it.

[tarekgh]

I changed the List to Array. I'll address the tags sorting and tags insensitive comparisons in a separate PR when addressing #86614.

[tarekgh]

Fixes#77514

[ghost]

Note regarding the new-api-needs-documentation label:

This serves as a reminder for when your PR is modifying a ref *.cs file and adding/modifying public APIs, please make sure the API implementation in the src *.cs file is documented with triple slash comments, so the PR reviewers can sign off that change.

[stephentoub]

Weren't we going to use a subclassed Meter who's exposed Dispose was a nop?

[tarekgh]

I will investigate the disposal issue further to determine the best possible solution. I'll track the issue and will link it here.

[stephentoub]

Ok. If we don't end up changing this, we need to change the name of the method. Calling it Create and returning something that's IDisposable but then telling people in docs not to Dispose it will lead to a pit of failure.

[tarekgh]

I opened #86592

[stephentoub]

The consumer could do:

((List<...>)meter.Tags).Add(...);

Would that mess anything up?

[tarekgh]

Users doing that will be missing up with themselves. It is not good to depend on the internal implementation anyway. But even if they do that in this case, it will not cause crashes or terrible things. Will just be updating a list that not supposed to be mutated.

[noahfalk]

mostly looked good, a few comments inline

[noahfalk]

Oh I missed this. At some point in the past I thought there was an explicit RecordObservableInstrument() API. Doing it this way feels weird to me because now GetMeasurements() is mutating the list every time it is called. I think the design would be better if we have a separate explicit API that records observable instruments. For example imagine a user wants to capture measurements at several points, then verify them:

//arrangeusingrecorder=newInstrumentRecorder<int>(observableInstrument);//actSetState1();recorder.GetMeasurements();SetState2();recorder.GetMeasurements();SetState3();recorder.GetMeasurements();//assert//I want to confirm that all three cases produced a measurement.//but I can't use GetMeasurements() here because it changes the count to 4.Assert.Equals(3,recorder.GetMeasurements().Length);

Users could of course workaround it by saving a snapshot of the measurements earlier, but needing to treat the API differently for observable and non-observable instruments feels awkward. Having API called 'GetXXX' change the thing it is getting also seems like it wouldn't align with our naming rules.

[tarekgh]

I'll keep whatever I have in this PR and then we can talk about this one to know if we really need a new API.

[noahfalk]

Any reason to use List rather than array? We should never modify this collection in the future. Also I'd suggest we sort it.

[tarekgh]

I changed the List to Array. I'll address the tags sorting and tags insensitive comparisons in a separate PR when addressing #86614.

[tarekgh]

Fixes#77514

[ghost]

Note regarding the new-api-needs-documentation label:

This serves as a reminder for when your PR is modifying a ref *.cs file and adding/modifying public APIs, please make sure the API implementation in the src *.cs file is documented with triple slash comments, so the PR reviewers can sign off that change.

[stephentoub]

Weren't we going to use a subclassed Meter who's exposed Dispose was a nop?

[tarekgh]

I will investigate the disposal issue further to determine the best possible solution. I'll track the issue and will link it here.

[stephentoub]

Ok. If we don't end up changing this, we need to change the name of the method. Calling it Create and returning something that's IDisposable but then telling people in docs not to Dispose it will lead to a pit of failure.

[tarekgh]

I opened #86592

[stephentoub]

The consumer could do:

((List<...>)meter.Tags).Add(...);

Would that mess anything up?

[tarekgh]

Users doing that will be missing up with themselves. It is not good to depend on the internal implementation anyway. But even if they do that in this case, it will not cause crashes or terrible things. Will just be updating a list that not supposed to be mutated.

[noahfalk]

mostly looked good, a few comments inline

[noahfalk]

Oh I missed this. At some point in the past I thought there was an explicit RecordObservableInstrument() API. Doing it this way feels weird to me because now GetMeasurements() is mutating the list every time it is called. I think the design would be better if we have a separate explicit API that records observable instruments. For example imagine a user wants to capture measurements at several points, then verify them:

//arrangeusingrecorder=newInstrumentRecorder<int>(observableInstrument);//actSetState1();recorder.GetMeasurements();SetState2();recorder.GetMeasurements();SetState3();recorder.GetMeasurements();//assert//I want to confirm that all three cases produced a measurement.//but I can't use GetMeasurements() here because it changes the count to 4.Assert.Equals(3,recorder.GetMeasurements().Length);

Users could of course workaround it by saving a snapshot of the measurements earlier, but needing to treat the API differently for observable and non-observable instruments feels awkward. Having API called 'GetXXX' change the thing it is getting also seems like it wouldn't align with our naming rules.

[tarekgh]

I'll keep whatever I have in this PR and then we can talk about this one to know if we really need a new API.

[noahfalk]

Any reason to use List rather than array? We should never modify this collection in the future. Also I'd suggest we sort it.

[tarekgh]

I changed the List to Array. I'll address the tags sorting and tags insensitive comparisons in a separate PR when addressing #86614.

[tarekgh]

Fixes#77514

[ghost]

Note regarding the new-api-needs-documentation label:

This serves as a reminder for when your PR is modifying a ref *.cs file and adding/modifying public APIs, please make sure the API implementation in the src *.cs file is documented with triple slash comments, so the PR reviewers can sign off that change.

[stephentoub]

Weren't we going to use a subclassed Meter who's exposed Dispose was a nop?

[tarekgh]

I will investigate the disposal issue further to determine the best possible solution. I'll track the issue and will link it here.

[stephentoub]

Ok. If we don't end up changing this, we need to change the name of the method. Calling it Create and returning something that's IDisposable but then telling people in docs not to Dispose it will lead to a pit of failure.

[tarekgh]

I opened #86592

[stephentoub]

The consumer could do:

((List<...>)meter.Tags).Add(...);

Would that mess anything up?

[tarekgh]

Users doing that will be missing up with themselves. It is not good to depend on the internal implementation anyway. But even if they do that in this case, it will not cause crashes or terrible things. Will just be updating a list that not supposed to be mutated.

[noahfalk]

mostly looked good, a few comments inline

[noahfalk]

Oh I missed this. At some point in the past I thought there was an explicit RecordObservableInstrument() API. Doing it this way feels weird to me because now GetMeasurements() is mutating the list every time it is called. I think the design would be better if we have a separate explicit API that records observable instruments. For example imagine a user wants to capture measurements at several points, then verify them:

//arrangeusingrecorder=newInstrumentRecorder<int>(observableInstrument);//actSetState1();recorder.GetMeasurements();SetState2();recorder.GetMeasurements();SetState3();recorder.GetMeasurements();//assert//I want to confirm that all three cases produced a measurement.//but I can't use GetMeasurements() here because it changes the count to 4.Assert.Equals(3,recorder.GetMeasurements().Length);

Users could of course workaround it by saving a snapshot of the measurements earlier, but needing to treat the API differently for observable and non-observable instruments feels awkward. Having API called 'GetXXX' change the thing it is getting also seems like it wouldn't align with our naming rules.

[tarekgh]

I'll keep whatever I have in this PR and then we can talk about this one to know if we really need a new API.

[noahfalk]

Any reason to use List rather than array? We should never modify this collection in the future. Also I'd suggest we sort it.

[tarekgh]

I changed the List to Array. I'll address the tags sorting and tags insensitive comparisons in a separate PR when addressing #86614.