sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: go
Issue: x/telemetry/config: add gopls/*/latency histograms
Labels: gopls,telemetry,Telemetry-Proposal

### Counter names

gopls/completion/latency:{<10ms,<50ms, <100ms, <200ms, <500ms, <1s, <5s, >=5s}
gopls/definition/latency:{<10ms,<50ms, <100ms, <200ms, <500ms, <1s, <5s, >=5s}
gopls/hover/latency:{<10ms,<50ms, <100ms, <200ms, <500ms, <1s, <5s, >=5s}
gopls/implementations/latency:{<10ms,<50ms, <100ms, <200ms, <500ms, <1s, <5s, >=5s}
gopls/references/latency:{<10ms,<50ms, <100ms, <200ms, <500ms, <1s, <5s, >=5s}
gopls/symbol/latency:{<10ms,<50ms, <100ms, <200ms, <500ms, <1s, <5s, >=5s}

### Description

These counters measure server-side observed latency for various latency sensitive LSP operations. For pragmatic reasons, as well as to reduce variability, timing starts when gopls actually begins handling the request, and does not include jsonrpc2 queue time.

Bucketing is approximately exponential, though adjusted to capture meaningful boundaries. For example, the default completion budget is 100ms, and we typically think of anything faster than 200ms as OK. 500ms, 1s, and 5s are various landmarks of slowness.

More precisely, the <10ms bucket captures latency in the range [0, 10ms), and subsequent buckets save the last capture [P, V), where P is the previous bucket endpoint and V is the current bucket endpoint. The >=5 bucket captures everything else. **Is there a different convention I should be following for bucket naming?**.

The set of operations for this initial batch of instrumentation is chosen based on our experience, as the most critical latency-sensitive operations we support. (CC @adonovan for his opinion on this)

### Rationale

The latency of these operations greatly affects the experience of using gopls. With the large variety of editing environments that gopls supports, it is impossible to adequately benchmark these operations in every scenario. Furthermore, users tend not to file issues for incremental performance regressions ("boiling the frog"), and we've seen cases where a significant regression went unnoticed by the team and largely unreported for months (for example #62665).

By capturing these latency distributions, we can form a picture of the typical user experience, identify the frequency of outliers / atypical experiences, catch performance regressions following releases, and better prioritize our performance work.

### Do the counters carry sensitive user information?

No.

### How?

We'll instrument timing around these operations in the relevant gopls request handlers.

### Proposed Graph Config

```Text
counter: gopls/completion/latency:{<10ms,<50ms, <100ms, <200ms, <500ms, <1s, <5s, >=5s}
title: Latency of gopls completion requests
description: Server-side latency observed while handling the LSP textDocument/completion request.
type: histogram
program: golang.org/x/tools/gopls
version: v0.14.0  # the first binary version containing this counter.
```


### New or Update

New
Repository: vscode
Issue: [wsl] Can't run `code .` when offline and VS Code got updated
Labels: bug,WSL

<!-- ⚠️⚠️ Do Not Delete This! bug_report_template ⚠️⚠️ -->
<!-- Please read our Rules of Conduct: https://opensource.microsoft.com/codeofconduct/ -->
<!-- 🕮 Read our guide about submitting issues: https://github.com/microsoft/vscode/wiki/Submitting-Bugs-and-Suggestions -->
<!-- 🔎 Search existing issues to avoid creating duplicates. -->
<!-- 🧪 Test using the latest Insiders build to see if your issue has already been fixed: https://code.visualstudio.com/insiders/ -->
<!-- 💡 Instead of creating your report here, use 'Report Issue' from the 'Help' menu in VS Code to pre-fill useful information. -->
<!-- 🔧 Launch with `code --disable-extensions` to check. -->
Does this issue occur when all extensions are disabled?: Yes

<!-- 🪓 If you answered No above, use 'Help: Start Extension Bisect' from Command Palette to try to identify the cause. -->
<!-- 📣 Issues caused by an extension need to be reported directly to the extension publisher. The 'Help > Report Issue' dialog can assist with this. -->
- VS Code Version: 6509174151d557a81c9d0b5f8a5a1e9274db5585
- OS Version: Windows 11 + Ubuntu 20.04 WSL

## Summary

Can't use VS Code Server inside of WSL when I'm not connected to the Internet and I don't have the latest version installed

## Current behavior

When trying to open vscode form WSL while not connected to the Internet, if it hasn't been opened in a while one gets this:

```bash
$ code .

Updating VS Code Server to version 6509174151d557a81c9d0b5f8a5a1e9274db5585
Removing previous installation...
Installing VS Code Server for x64 (6509174151d557a81c9d0b5f8a5a1e9274db5585)
Downloading: 100%
Failed
--2023-09-20 15:16:58--  https://update.code.visualstudio.com/commit:6509174151d557a81c9d0b5f8a5a1e9274db5585/server-linux-x64/stable
Resolving update.code.visualstudio.com (update.code.visualstudio.com)... failed: Temporary failure in name resolution.
wget: unable to resolve host address ‘update.code.visualstudio.com’
ERROR: Failed to download https://update.code.visualstudio.com/commit:6509174151d557a81c9d0b5f8a5a1e9274db5585/server-linux-x64/stable to /home/ed/.vscode-server/bin/6509174151d557a81c9d0b5f8a5a1e9274db5585-1695215807.tar.gz
```

Result: unable to use vscode server until I connect back to the Internet.

## Expected behavior

Checking internet aaccess (or better, `update.code.visualstudio.com` access) before actually proceeding to uninstall the existing version of vscode server and trying to install the new one, so that users don't have their vscode access denied while they're not connected to Internet.
Repository: kubernetes
Issue: Resource Management of ETCD Load
Labels: sig/api-machinery,kind/feature,triage/accepted,wg/batch,sig/etcd

### What would you like to be added?

There should be Resource Management for tracking etcd load. This can then be used as a Resource Quota for Jobs to ensure that they (and potentially kubelet) do not spin up Pods faster than etcd can handle.

K8s Docs:
https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#extended-resources
https://kubernetes.io/docs/concepts/policy/resource-quotas/



### Why is this needed?

For people dealing with extremely high-throughput batch work (i.e 1000's jobs / second, lasting 1-2 mins each), etcd starts to become a real problem. There should be an in-k8s solution to this.

Whether it is through Resource Quotas or some other medium, I think this is something interesting to be explored. Happy to make this Ticket more detailed as required, and start the KEP if this is something that is interesting to folks.

Links to back up this point:
- https://etcd.io/docs/v3.5/op-guide/performance/
- https://github.com/armadaproject/armada: A scheduling solution partially designed around this problem.
Repository: flutter
Issue: [Impeller] Consolidate and clearly document transform handling across the blend filter variants.
Labels: P2,e: impeller,team-engine,triaged-engine

The various blend paths (in  and foreground blends project snapshots onto a new texture with `GetCoverageUVs`, but this concept is quite confusing and prone to mistakes.

Comprehensively document the texture coordinate management and transformation behavior in both `framebuffer_blend_contents.cc` and `blend_filter_contents.cc`.
Repository: godot
Issue: Next Pass shaders aren't chained together correctly
Labels: bug,topic:rendering,topic:shaders

### Godot version

v4.1.1.stable.official [bd6af8e0e]

### System information

Windows 11 - Godot v4.1.1.stable - Vulkan (Forward+) - RTX 3060 Laptop GPU

### Issue description

When creating a next pass shader material with more than two shaders chained together, the end behavior is unexpected and unpredictable.

In some viewports, the expected end result is visible, but only when rotating the object. In other viewports, the visible result appears to be only a subset of the assigned shaders, and depending on the rotation angle, that subset can change.

### Steps to reproduce

1) Create a MeshInstance3D with a box mesh, and assign a new ShaderMaterial called blue_white_stripes. Apply this code:

```
shader_type spatial;

uniform float stripe_frequency : hint_range(0.1, 10.0) = 8.0;

void fragment() {
    float stripe = step(0.5, fract(UV.y * stripe_frequency));
    vec3 blueColor = vec3(0.0, 0.0, 1.0);
    vec3 stripeColor = vec3(1.0, 1.0, 1.0);
    ALBEDO = mix(blueColor, stripeColor, stripe);
}
```

This will apply a pattern of blue and white stripes to the box.

![godotbug1](https://github.com/godotengine/godot/assets/5056836/a5d88a7f-0570-45c7-8ef3-89659197354c)


2) Create a next pass shader after blue_white_stripes, called "green", and apply this code:

```
shader_type spatial;

uniform sampler2D SCREEN_TEXTURE : hint_screen_texture, filter_linear_mipmap;

void fragment() {
    vec4 screen_sample = texture(SCREEN_TEXTURE, SCREEN_UV);
    ALBEDO = vec3(0.0, screen_sample.g, 0.0);
}
```

This should add a green tint to the previous blue and white pattern, so that now the box has green and black stripes.
![godotbug2](https://github.com/godotengine/godot/assets/5056836/43c4237a-c404-4817-8845-d2eeff44bb06)

3) Create a next pass shader after green, called "transparent_stripes", and apply this code:

```
shader_type spatial;

uniform sampler2D SCREEN_TEXTURE : hint_screen_texture, filter_linear_mipmap;

void fragment() {
    vec4 screen_sample = texture(SCREEN_TEXTURE, SCREEN_UV);
    ALBEDO = vec3(1.0, screen_sample.g, 0.0);
}
```

This will apply a red and green tint, which makes the box look red and yellow-striped.

Adjust the view to have an extra view port, and change it to show what the scene's Camera3D sees when pointed at the box mesh. Adjust the box mesh's rotation and observe the shader result. In some viewports, it shows the expected yellow/red stripes, in others, it shows the green/black stripes.

![godotbug](https://github.com/godotengine/godot/assets/5056836/06772112-2c91-491c-8590-d7c413f72cb5)


### Minimal reproduction project

EDIT: The previous link was broken so I just uploaded to github directly.

[nextpass_bug_cube.zip](https://github.com/godotengine/godot/files/12678778/nextpass_bug_cube.zip)
Repository: flutter
Issue: Use libDispatch for thread management on iOS.
Labels: platform-ios,engine,c: proposal,P2,team-engine,triaged-engine

On iOS, the engine manages its own thread pools and thread priorties. On Android, we've found that this is insufficent to get stable performance and so we've added thread affintieis as well: https://github.com/flutter/flutter/issues/134452

iOS appears to have similar issues, where interactive work can be scheduled on E cores based on herustics for how expensive the thread has been. For example, running an app with a very simple animation shows only the E cores active:

![image](https://github.com/flutter/flutter/assets/8975114/bdc4b2a0-87ec-4478-aef3-00ed0768f89b)


Whereas running an app with the tessellation benchmark switches us onto the P cores.

![image](https://github.com/flutter/flutter/assets/8975114/5943e4e0-13d3-4a13-861a-98a2c55c6949)


Generally this works well on iOS, but has similar issues to android : if we suddenly have a more expensive frame workload then we risk dropping it. Additionally, there is an issue that performance improving changes may regress our devicelab metrics  whereas performance regressing changes may improve the metrics.

As an experiment, we should determine whether libdispatch with the correct QoS classes set improves 90/99/worst frame times in any of our benchmarks.

Links: 
  * https://github.com/flutter/engine/pull/15673/
  * https://github.com/flutter/engine/pull/35355/
Repository: flutter
Issue: `pub_get_offline.py` triggers on CI, but not locally
Labels: engine,P2,c: tech-debt,team-engine,triaged-engine

Locally:

```shell
$ python3 ./tools/pub_get_offline.py
```

On [CI](https://ci.chromium.org/ui/p/flutter/builders/try/Linux%20Engine%20Drone/1389640/overview):

```shell
running 'python3 src/flutter/tools/pub_get_offline.py' in '/b/s/w/ir/cache/builder'
"/b/s/w/ir/cache/builder/src/third_party/dart/tools/sdks/dart-sdk/bin/dart pub get --offline" failed in "/b/s/w/ir/cache/builder/src/flutter/tools/pkg/git_repo_tools" with status 69:
b"Resolving dependencies...\nBecause every version of process_runner from path depends on file any which doesn't exist (could not find package file in cache), process_runner from path is forbidden.\nSo, because git_repo_tools depends on process_runner from path, version solving failed.\n\nTry again without --offline!\n"
Error: Command 'python3 src/flutter/tools/pub_get_offline.py' returned non-zero exit status 1 in /b/s/w/ir/cache/builder
"/b/s/w/ir/cache/builder/src/third_party/dart/tools/sdks/dart-sdk/bin/dart pub get --offline" failed in "/b/s/w/ir/cache/builder/src/flutter/tools/pkg/git_repo_tools" with status 69:
b"Resolving dependencies...\nBecause every version of process_runner from path depends on file any which doesn't exist (could not find package file in cache), process_runner from path is forbidden.\nSo, because git_repo_tools depends on process_runner from path, version solving failed.\n\nTry again without --offline!\n"
```

I wonder if like, `pubspec.lock` needs to get blown away or something to make this hermetic locally?
Repository: neovim
Issue: The culling of vim.lsp.util
Labels: refactor,lua,lsp

### Problem

`vim.lsp.util` is a dumpster that needs to be cleaned up. This process has already been started in #25073. But the pruning must continue.

This is a tracking issue for _substantially_ reducing the size and scope of `vim.lsp.util`. Ideally, it will be removed completely (deprecated first, of course, and removed in a future release).

In particular, new homes should be found for:

- [ ] `_normalize_markdown`
  - This should be made public, but not under `vim.lsp.util`. TBD on the correct namespace for this
- [ ] `open_floating_preview`
  - This is a useful utility function for easily creating floats, but it tries to do too much and has become over engineered. Move this to `vim.ui.open_win`. (#25514)
- [ ] `make_floating_popup_options`
  - This should just be part of `vim.ui.open_float`. Deprecate.
- [ ] `_make_floating_popup_size`
  - Same as above.
- [x] `_str_utfindex_enc` and `_str_byteindex_enc`
  - These are advertised as "convenience wrappers" around `vim.str_utfindex` and `vim.str_byteindex`, respectively. Consider updating those functions to accept an encoding instead. https://github.com/neovim/neovim/pull/30915
- [x] `set_lines`
  - I don't see any usages of this in our own code. This should be deprecated and deleted. Plugins can do this themselves, it is not that hard, and we don't need to provide little utility functions for every possible thing that can be done.
  - Deprecated in https://github.com/neovim/neovim/pull/26742, will be removed in 0.12.
- [ ] `apply_text_edits`
  - Can this be moved to e.g. `vim.lsp.buf`? @mfussenegger 
- [x] `_get_completion_item_kind_name`
  - This is a one line function. Why is this needed? Can it be inlined/deleted? @mfussenegger 
  - Removed in https://github.com/neovim/neovim/pull/25733
- [x] `text_document_completion_list_to_complete_items`
  - The name alone suggests this is a special purpose function and doesn't belong in "util". Is there a more appropriate location?
  - Removed in https://github.com/neovim/neovim/pull/28774
- [ ] `stylize_markdown`
  - Deprecate once `normalize_markdown` is public and `vim.ui.open_float` exists. At that point this is no longer needed or necessary.

The list above is non-exhaustive, it may be updated with new items as the effort progresses.
Repository: go
Issue: x/vulndb: converge on symbol names for methods defined on aliased types
Labels: NeedsInvestigation,vulncheck or vulndb

Suppose there is an incoming database report for a vulnerability where the fix is patching the body of a method named `Vuln` :
```
func (b B) Vuln() {
   // ...
  + // fix
}
```
Manual vulnerability symbol extraction could likely add the symbol `B.Vuln` to the database.

But if the type `B` is defined as a type alias `type B = A`, the actual symbol name that govulncheck would see when encountering the method will be `A.Vuln`. In that case, govulncheck would miss the use of the vulnerable method.

@golang/vulndb
Repository: flutter
Issue: Add web benchmarks that measure asynchronous scene rendering
Labels: engine,P2,e: web_skwasm,team-web,triaged-web

Our current web benchmarks measure building and rendering the scene. In the Skwasm case, this only covers the part that initially occurs on the UI thread. The remaining work that occurs on the web worker is not measured or reflected in our benchmarks. We should add some measurements that capture the following information:
* Time spent waiting for the web worker to return
* Time spent committing image bitmaps to their canvases and mutating platform views
* Any dropped frames due to the web worker being too busy
Repository: godot
Issue: JSON Resource won't load correctly on re-opening of Godot (only when using the default .tres extension)
Labels: discussion,topic:editor

### Godot version

v4.2.dev4.mono.official [549fcce5f]

### System information

Godot v4.2.dev4.mono - Windows 10.0.22621 - Vulkan (Forward+) - dedicated NVIDIA GeForce GTX 1050 (NVIDIA; 30.0.14.7219) - Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz (8 Threads)

### Issue description

When using a JSON resource, the built-in text editor will not load the data after you re-open the project.
Although the content is still there in the raw file when looking at it outside of Godot.

I tested the same with a regular text file inside Godot, and that has no issues.

The strange thing that I did find out, if I rename the created json resource and change it to have an actual .json extension, this issue  is solved. So it only happens when it has the .tres extension.

> _Possible cause or related issue that I noticed only once: is that when you have both test.json and test.tres, test.tres will load from the one with .json extension.
> So maybe that's why it's empty when it's just the .tres file, because it's trying to find the .json file that might not exist.
> But this one I couldn't reproduce that quickly, but will add more info if I do notice it again.
> But maybe that can help you guys in the right direction._

### Steps to reproduce

Create a JSON resource, letting it default to the .tres extension when saving.
Open it in the built-in text editor.
Add some test JSON data:
`{
"content": "test"
}`
Save the file and project
Close the project
Re-open the project

It is now empty in the text editor, while the raw file still contains the data (until you save the loaded empty data I guess)
If you do save it as a .json file, it has no issues.

### Minimal reproduction project


[jsonbug.zip](https://github.com/godotengine/godot/files/12678064/jsonbug.zip)
Repository: PowerToys
Issue: File Explorer / Preview Pane
Labels: Idea-Enhancement,Product-File Explorer,Cost-Small,Needs-Triage

### Description of the new feature / enhancement

Add the possibility to add a new source file extension like .vue ...

### Scenario when this would be used?

On windows explorer preview pane

### Supporting information

_No response_
Repository: pytorch
Issue: [RFC][TorchElastic] topology info in training apps/ranks
Labels: oncall: distributed,triaged,module: elastic

### 🚀 The feature, motivation and pitch

RFC PR: https://github.com/pytorch/rfcs/pull/57 ([preview]( https://github.com/pytorch/rfcs/pull/57/files?short_path=c8cb2fb#diff-c8cb2fba3757888ba87a91b1f9c5d39c5e19b64b6289994d0e6d2e699aac625e)) 

cc @mrshenli @pritamdamania87 @zhaojuanmao @satgera @rohan-varma @gqchen @aazzolini @osalpekar @jiayisuse @H-Huang @kwen2501 @awgu @penguinwu @dzhulgakov @kiukchung @d4l3k @wconstab 

### Alternatives

_No response_

### Additional context

_No response_
Repository: deno
Issue: Deno Userland Jupyter Messaging library: `comms`
Labels: feat,deno jupyter

# The Jupyter `comms` protocol

Jupyter has the concept of [custom messages](https://jupyter-client.readthedocs.io/en/latest/messaging.html#custom-messages) that are bidirectional messages between a frontend and the kernel. Famously, these are used to implement the IPython widgets. At the most basic we need a way to listen for comm messages on a particular `comm_id`. Comm messages come in on the `shell` channel while responses will go out on `iopub`.

The spec itself is pretty short as all we have to implement messaging wise is sending `comm_open`, `comm_msg`, and `comm_close`.

Userland libraries will want to register to be available for when the frontend requests a `comm_open` so that they can receive all `comm_msg` for a given `comm_id`. Given Deno's commitment to web standards, I'm assuming we would use event listeners.

## Motivations

The big reason to implement these messages is to be able to create two-way data bindings that allow you to set values on objects both in the frontend and the backend:

<img width="829" alt="image" src="https://github.com/denoland/deno/assets/836375/99be8089-9e81-46cc-8408-ace44cfa8ed0">

This gives us forms, interactive maps, etc.

Where, to me, it gets more wild and interesting is being able to send `esm` and `css` code with [anywidget](https://github.com/manzt/anywidget). cc @manzt

![1_VCG-57YX8IrfTyeby3Ybjg](https://github.com/denoland/deno/assets/836375/0c2d5ea1-a432-4b8d-b724-10f7110fe878)

In order to get there though, we have to start with the primitives for comms sending and receiving in the rust portion of the kernel.
Repository: next.js
Issue: Link prefetch requests are throwing 404 errors, but only in production.
Labels: bug,Pages Router

### Link to the code that reproduces this issue

https://codesandbox.io/p/sandbox/friendly-ganguly-qmrdl2

### To Reproduce

The provided reproduction link doesn't reproduce the issue, as I only encounter the problem in the production environment, but it is a simplified version of the code that I am having issues with. A page with the issue can be seen [here](https://jefferson-pre-production-b2abcbbnd2bqdjfg.z01.azurefd.net/medicare/en/). To reproduce my production environment, use the following steps.
1. Deploy nextjs app with multiple Link tags on a page to azure static web app.
2. Put that web app behind an azure front door instance
3. Visit the site and check the logs to see whether the prefetch requests worked

### Current vs. Expected behavior

The Link prefetch request throws a 404 error for a page that exists, when it should be returning the json data.

### Verify canary release

- [X] I verified that the issue exists in the latest Next.js canary release

### Provide environment information

Get an error when I run next info because the package.json file isn't registered in npmjs.org (nor is it supposed to be).

Operating System
Not sure, as the documentation doesn't specify, but I suspect it's running Linux.

Binaries
node: 16.13.2
npm: 8.18.0

Packages
next: 13.5.1
babel-plugin-superjson-next: 0.4.3 (used to return date objects for typescript, since next leaves them as strings)


### Which area(s) are affected? (Select all that apply)

Data fetching (gS(S)P, getInitialProps)

### Additional context

I'm not sure why it's unable to retrieve the data, as the pages themselves resolve when visited and the data requests work fine in the development environment.
Repository: flutter
Issue: FLTEnableWideGamut should be checked in app bundle as well as main bundle
Labels: platform-ios,engine,good first issue,P2,team-engine,triaged-engine

See for example check we do for `FLTEnableImpeller`.