Nutrition data entered by users is not syncing across devices, causing discrepancies in the data.
Steps to Reproduce:

1. Enter nutrition data on one device.
2. Check if the data is synced to other devices with the same account.
3. Verify that the data is not synced.

The app is calculating calories burned inaccurately, leading to incorrect data in the user's profile.
Steps to Reproduce:

1. Perform a workout session with known calorie burn.
2. Check the 'Calories Burned' section of the app.
3. Verify that the calculated calories burned do not match the expected value.

It would be useful to have a small library of commonly used health checks. In the scope of this issue, a DNS resolver check should be implemented (e.g. using LookupHost method if net.Resolver). Optimally, the implementation should support timeouts from the context.Context value that is being passed to every health check function.

A few constraints to keep things clean and simple:

• The check should be added to the checks module that you can find in the development branch.
• As with all health check functions of this library, the check implementation should support accepting and forwarding context.Context that is being passed to each health check function.
• If the health check requires external external modules or other dependencies, the check should be implemented as a separate Go module(similarly how it is done for the tests, that require dependencies to other packages as well). This is required to avoid that when people import the base library, they also need to import all dependencies of all provided checks.
• The check should have a README.md in its root directory that describes how to use it and maybe what to look out for.
• You should provide a test that checks at least the happy path. If a docker container is required to properly test the check, the docker container can be added to the docker-compose.yaml file in the checks base package.

Should you have questions or require help, please join our discord chat room.

It would be useful to have a library of commonly used health checks. In the scope of this issue, a health check should be implemented that checks if a Kafka consumer is alive. Strategies on how to do this can be discussed here prior to implementation.

A few constraints to keep things clean and simple:

• The check should be added to the checks module that you can find in the development branch.
• As with all health check functions of this library, the check implementation should support accepting and forwarding context.Context that is being passed to each health check function.
• If the health check requires external external modules or other dependencies, the check should be implemented as a separate Go module(similarly how it is done for the tests, that require dependencies to other packages as well). This is required to avoid that when people import the base library, they also need to import all dependencies of all provided checks.
• The check should have a README.md in its root directory that describes how to use it and maybe what to look out for.
• You should provide a test that checks at least the happy path. If a docker container is required to properly test the check, the docker container can be added to the docker-compose.yaml file in the checks base package.

Should you have questions or require help, please join our discord chat room.

It would be useful to have a small library of commonly used health checks. In the scope of this issue, a TCP check should be implemented (e.g. calling net.DialTimeout("tcp", addr, timeout) and return it's result). Optimally, the implementation should respect the context.Context value that is being passed to each health check function (e.g., by using the Deadline from the context to pass it as a parameter to net.DialTimeout (or pass the entire context if there is a way to do that).

A few constraints to keep things clean and simple:

• The check should be added to the checks module that you can find in the development branch.
• As with all health check functions of this library, the check implementation should support accepting and forwarding context.Context that is being passed to each health check function.
• If the health check requires external external modules or other dependencies, the check should be implemented as a separate Go module(similarly how it is done for the tests, that require dependencies to other packages as well). This is required to avoid that when people import the base library, they also need to import all dependencies of all provided checks.
• The check should have a README.md in its root directory that describes how to use it and maybe what to look out for.
• You should provide a test that checks at least the happy path. If a docker container is required to properly test the check, the docker container can be added to the docker-compose.yaml file in the checks base package.

Should you have questions or require help, please join our discord chat room.

Implement a dark mode theme option to provide users with a more comfortable viewing experience, especially in low-light environments.
Suggestions:

• Add a toggle switch in the app settings to enable/disable dark mode.
• Adjust color schemes and contrast for optimal readability in dark mode.

It would be useful to have a library of commonly used health checks. In the scope of this issue, a health check should be implemented that checks if Mongo DB is alive (e.g. by pinging Mongo DB and see if the ping result is successful).

A few constraints to keep things clean and simple:

• The check should be added to the checks module that you can find in the development branch.
• As with all health check functions of this library, the check implementation should support accepting and forwarding context.Context that is being passed to each health check function.
• If the health check requires external external modules or other dependencies, the check should be implemented as a separate Go module(similarly how it is done for the tests, that require dependencies to other packages as well). This is required to avoid that when people import the base library, they also need to import all dependencies of all provided checks.
• The check should have a README.md in its root directory that describes how to use it and maybe what to look out for.
• You should provide a test that checks at least the happy path. If a docker container is required to properly test the check, the docker container can be added to the docker-compose.yaml file in the checks base package.

Should you have questions or require help, please join our discord chat room.

Users report that their exercise log is not updating with their latest workout sessions.
Steps to Reproduce:

1. Go to the 'Exercise Log' page.
2. Select the option to add a new workout session.
3. Fill in the details of the workout session.
4. Click on the 'Save' button.
5. Check if the newly added workout session appears in the exercise log.

It would be useful to have a library of commonly used health checks. In the scope of this issue, a health check should be implemented that checks if Memcached is alive (e.g. by pinging Memcached and see if the ping result is successful).

A few constraints to keep things clean and simple:

• The check should be added to the checks module that you can find in the development branch.
• As with all health check functions of this library, the check implementation should support accepting and forwarding context.Context that is being passed to each health check function.
• If the health check requires external external modules or other dependencies, the check should be implemented as a separate Go module(similarly how it is done for the tests, that require dependencies to other packages as well). This is required to avoid that when people import the base library, they also need to import all dependencies of all provided checks.
• The check should have a README.md in its root directory that describes how to use it and maybe what to look out for.
• You should provide a test that checks at least the happy path. If a docker container is required to properly test the check, the docker container can be added to the docker-compose.yaml file in the checks base package.

Should you have questions or require help, please join our discord chat room.

This doesn't happen with unit tests, maybe there is a difference when using httptest?
With a real handler I get the response with a text/plain Content-Type. I guess this is because the status is emitted before the Content-Type (ultimately set here).

It would be useful to have a small library of commonly used health checks. In the scope of this issue, an HTTP check should be implemented (e.g. calling an http.Client HTTP method and return it's result). Optimally, the implementation should respect the context.Context value that is being passed to each health check function (e.g., by using the Deadline from the context to pass it as a paramter of http.Client (or pass the entire context if there is a way to do that).

A few constraints to keep things clean and simple:

• The check should be added to the checks module that you can find in the development branch.
• As with all health check functions of this library, the check implementation should support accepting and forwarding context.Context that is being passed to each health check function.
• If the health check requires external external modules or other dependencies, the check should be implemented as a separate Go module(similarly how it is done for the tests, that require dependencies to other packages as well). This is required to avoid that when people import the base library, they also need to import all dependencies of all provided checks.
• The check should have a README.md in its root directory that describes how to use it and maybe what to look out for.
• You should provide a test that checks at least the happy path. If a docker container is required to properly test the check, the docker container can be added to the docker-compose.yaml file in the checks base package.

Should you have questions or require help, please join our discord chat room.

It would be useful to have a library of commonly used health checks. In the scope of this issue, a health check should be implemented that checks if a mail server (SMTP) is alive and can be used to send emails, e.g. by using Golangs https://pkg.go.dev/net/smtp package.

A few constraints to keep things clean and simple:

• The check should be added to the checks module that you can find in the development branch.
• As with all health check functions of this library, the check implementation should support accepting and forwarding context.Context that is being passed to each health check function.
• If the health check requires external external modules or other dependencies, the check should be implemented as a separate Go module(similarly how it is done for the tests, that require dependencies to other packages as well). This is required to avoid that when people import the base library, they also need to import all dependencies of all provided checks.
• The check should have a README.md in its root directory that describes how to use it and maybe what to look out for.
• You should provide a test that checks at least the happy path. If a docker container is required to properly test the check, the docker container can be added to the docker-compose.yaml file in the checks base package.

Should you have questions or require help, please join our discord chat room.

It would be useful to have a small library of commonly used health checks. In the scope of this issue, a garbage collection max pause check should be implemented (e.g. calling runtime.ReadMemStats and see if the PauseNs returns a value that is above a certain threshold.

A few constraints to keep things clean and simple:

• The check should be added to the checks module that you can find in the development branch.
• As with all health check functions of this library, the check implementation should support accepting and forwarding context.Context that is being passed to each health check function.
• If the health check requires external external modules or other dependencies, the check should be implemented as a separate Go module(similarly how it is done for the tests, that require dependencies to other packages as well). This is required to avoid that when people import the base library, they also need to import all dependencies of all provided checks.
• The check should have a README.md in its root directory that describes how to use it and maybe what to look out for.
• You should provide a test that checks at least the happy path. If a docker container is required to properly test the check, the docker container can be added to the docker-compose.yaml file in the checks base package.

Should you have questions or require help, please join our discord chat room.

When a user created health check function panics, this health check library currently does not provide a means to recover from it automatically and continue. Instead, the application terminates. This behaviour is most likely is not wanted. Therefore, this library should provide a way to recover from panics right after the check function call (e.g.: here). The user should

• be able to able to opt out of this by configuration (e.g. by disabling it with a configuration option) and
• instead of panicking, the library should instead return an error.

It would be useful to have a small library of commonly used health checks. In the scope of this issue, a goroutine count check should be implemented (e.g. calling an count := runtime.NumGoroutine() and se if it is above a throeshold.

A few constraints to keep things clean and simple:

• The check should be added to the checks module that you can find in the development branch.
• As with all health check functions of this library, the check implementation should support accepting and forwarding context.Context that is being passed to each health check function.
• If the health check requires external external modules or other dependencies, the check should be implemented as a separate Go module(similarly how it is done for the tests, that require dependencies to other packages as well). This is required to avoid that when people import the base library, they also need to import all dependencies of all provided checks.
• The check should have a README.md in its root directory that describes how to use it and maybe what to look out for.
• You should provide a test that checks at least the happy path. If a docker container is required to properly test the check, the docker container can be added to the docker-compose.yaml file in the checks base package.

Should you have questions or require help, please join our discord chat room.

It would be useful to have a library of commonly used health checks. In the scope of this issue, a health check should be implemented that checks if a Kafka procuder is alive. Strategies on how to do this can be discussed here prior to implementation.

A few constraints to keep things clean and simple:

• The check should be added to the checks module that you can find in the development branch.
• As with all health check functions of this library, the check implementation should support accepting and forwarding context.Context that is being passed to each health check function.
• If the health check requires external external modules or other dependencies, the check should be implemented as a separate Go module(similarly how it is done for the tests, that require dependencies to other packages as well). This is required to avoid that when people import the base library, they also need to import all dependencies of all provided checks.
• The check should have a README.md in its root directory that describes how to use it and maybe what to look out for.
• You should provide a test that checks at least the happy path. If a docker container is required to properly test the check, the docker container can be added to the docker-compose.yaml file in the checks base package.

Should you have questions or require help, please join our discord chat room.

Is the call to handler (and thus checker) Start() duplicate here:

https://github.com/alexliesenfeld/health/blob/39c698eac61dfe95c78f2535d2f77e669f9ac5e1/config.go#L55-L57

since it's already done from newChecker() here?

https://github.com/alexliesenfeld/health/blob/39c698eac61dfe95c78f2535d2f77e669f9ac5e1/check.go#L89-L92

Also I wonder if the cancel() deferral doesn't immediately terminate the check here:

https://github.com/alexliesenfeld/health/blob/39c698eac61dfe95c78f2535d2f77e669f9ac5e1/handler.go#L23-L32

It would be useful to have a library of commonly used health checks. In the scope of this issue, a health check should be implemented that checks if Elasticsearch is alive (e.g. calling an sql.PingContext first and e.g. execute a query, such as 'SELECT 1 ' afterwards to see if MySQL is ready for query execution.

A few constraints to keep things clean and simple:

• The check should be added to the checks module that you can find in the development branch.
• As with all health check functions of this library, the check implementation should support accepting and forwarding context.Context that is being passed to each health check function.
• If the health check requires external external modules or other dependencies, the check should be implemented as a separate Go module(similarly how it is done for the tests, that require dependencies to other packages as well). This is required to avoid that when people import the base library, they also need to import all dependencies of all provided checks.
• The check should have a README.md in its root directory that describes how to use it and maybe what to look out for.
• You should provide a test that checks at least the happy path. If a docker container is required to properly test the check, the docker container can be added to the docker-compose.yaml file in the checks base package.

Should you have questions or require help, please join our discord chat room.

Enhance the app's functionality by integrating with popular wearable devices such as fitness trackers and smartwatches.
Suggestions:

• Enable automatic syncing of activity data from wearable devices to the app.
• Provide real-time notifications and insights based on wearable device data.

Enhance the app's user interface to improve accessibility for users with disabilities.
Suggestions:

• Add proper labels and descriptions for form fields.
• Ensure sufficient color contrast for text and background elements.
• Implement keyboard navigation support for all interactive elements.

It would be useful to have a library of commonly used health checks. In the scope of this issue, a health check should be implemented that checks the hosts disk space is above a preconfigured threshold (e.g. bny using syscall.Statfs and using the total and free disk blocks to see if the threshold constraints are met)

A few constraints to keep things clean and simple:

• The check should be added to the checks module that you can find in the development branch.
• As with all health check functions of this library, the check implementation should support accepting and forwarding context.Context that is being passed to each health check function.
• If the health check requires external external modules or other dependencies, the check should be implemented as a separate Go module(similarly how it is done for the tests, that require dependencies to other packages as well). This is required to avoid that when people import the base library, they also need to import all dependencies of all provided checks.
• The check should have a README.md in its root directory that describes how to use it and maybe what to look out for.
• You should provide a test that checks at least the happy path. If a docker container is required to properly test the check, the docker container can be added to the docker-compose.yaml file in the checks base package.

Should you have questions or require help, please join our discord chat room.

Add support for backing up user data to the cloud and restoring it across multiple devices.
Suggestions:

• Integrate with a cloud storage service (e.g., Google Drive, Dropbox) for data backup.
• Allow users to restore their data on new devices by signing in with their account.

Enable support for multiple languages to make the app accessible to users from different regions.
Suggestions:

• Provide language selection options in the app settings.
• Collaborate with translators to localize app content and user interface elements.

Commit 739c4a012ae74f2a6b7b2c9efebc7dcee916116a removed WithCustomAuth and WithBasicAuth.

What's the recommended way to obtain the same behaviour now?

It would be useful to have a library of commonly used health checks. In the scope of this issue, a health check should be implemented that checks if a GRPC endpoint is reachable, e.g. by using a HealthClient instance from google.golang.org/grpc/health/grpc_health_v1 to retrieve its status and see if it is "serving" (I.e. HealthCheckResponse_SERVING).

A few constraints to keep things clean and simple:

• The check should be added to the checks module that you can find in the development branch.
• As with all health check functions of this library, the check implementation should support accepting and forwarding context.Context that is being passed to each health check function.
• If the health check requires external external modules or other dependencies, the check should be implemented as a separate Go module(similarly how it is done for the tests, that require dependencies to other packages as well). This is required to avoid that when people import the base library, they also need to import all dependencies of all provided checks.
• The check should have a README.md in its root directory that describes how to use it and maybe what to look out for.
• You should provide a test that checks at least the happy path. If a docker container is required to properly test the check, the docker container can be added to the docker-compose.yaml file in the checks base package.

Should you have questions or require help, please join our discord chat room.

It would be useful to have a library of commonly used health checks. In the scope of this issue, a health check should be implemented that checks if Redis is alive (e.g. by pinging Redis and see if the ping result is successful).

A few constraints to keep things clean and simple:

• The check should be added to the checks module that you can find in the development branch.
• As with all health check functions of this library, the check implementation should support accepting and forwarding context.Context that is being passed to each health check function.
• If the health check requires external external modules or other dependencies, the check should be implemented as a separate Go module(similarly how it is done for the tests, that require dependencies to other packages as well). This is required to avoid that when people import the base library, they also need to import all dependencies of all provided checks.
• The check should have a README.md in its root directory that describes how to use it and maybe what to look out for.
• You should provide a test that checks at least the happy path. If a docker container is required to properly test the check, the docker container can be added to the docker-compose.yaml file in the checks base package.

Should you have questions or require help, please join our discord chat room.

It would be useful to have a library of commonly used health checks. In the scope of this issue, a health check should be implemented that checks if Postgres is alive (e.g. calling an sql.PingContext first and do a 'SELECT VERSION()' afterwards to see if Postgres is ready for query execution.

A few constraints to keep things clean and simple:

• As with all health check functions of this library, the check implementation should support accepting and forwarding context.Context that is being passed to each health check function.
• If the health check requires external external modules or other dependencies, the check should be implemented as a separate Go module(similarly how it is done for the tests, that require dependencies to other packages as well). This is required to avoid that when people import the base library, they also need to import all dependencies of all provided checks.
• The check should have a README.md in its root directory that describes how to use it and maybe what to look out for.
• You should provide a test that checks at least the happy path. If a docker container is required to properly test the check, the docker container can be added to the docker-compose.yaml file in the checks base package.

The streak counter for tracking consecutive days of healthy habits is displaying incorrect values.
Steps to Reproduce:

1. Perform a healthy habit activity for multiple consecutive days.
2. Check the streak counter.
3. Verify that the displayed streak count is incorrect.

Users are experiencing missing data in the sleep tracking section of the app.
Steps to Reproduce:

1. Navigate to the 'Sleep Tracker' page.
2. Check for recorded sleep sessions.
3. Verify that some sleep sessions are missing from the log.

Users are not receiving reminders to drink water throughout the day as configured in the settings.
Steps to Reproduce:

1. Go to the 'Settings' page.
2. Set up water intake reminders.
3. Wait for the specified reminder time.
4. Verify that no reminder is received.

When users try to input their weight data, it does not get saved to the database.
Steps to Reproduce:

1. Navigate to the 'Weight Tracker' section of the app.
2. Enter a weight value.
3. Click on the 'Save' button.
4. Verify that the weight data is not saved.

It would be useful to have a library of commonly used health checks. In the scope of this issue, a health check should be implemented that checks if MySQL is alive (e.g. calling an sql.PingContext first and e.g. execute a query, such as 'SELECT 1 ' afterwards to see if MySQL is ready for query execution.

A few constraints to keep things clean and simple:

• The check should be added to the checks module that you can find in the development branch.
• As with all health check functions of this library, the check implementation should support accepting and forwarding context.Context that is being passed to each health check function.
• If the health check requires external external modules or other dependencies, the check should be implemented as a separate Go module(similarly how it is done for the tests, that require dependencies to other packages as well). This is required to avoid that when people import the base library, they also need to import all dependencies of all provided checks.
• The check should have a README.md in its root directory that describes how to use it and maybe what to look out for.
• You should provide a test that checks at least the happy path. If a docker container is required to properly test the check, the docker container can be added to the docker-compose.yaml file in the checks base package.

Should you have questions or require help, please join our discord chat room.

It would be useful to have a library of commonly used health checks. In the scope of this issue, a health check should be implemented that checks if a mail server (IMAP) is alive and can be used to receive/read emails, e.g. by using Golangs https://pkg.go.dev/net/smtp package.

A few constraints to keep things clean and simple:

• The check should be added to the checks module that you can find in the development branch.
• As with all health check functions of this library, the check implementation should support accepting and forwarding context.Context that is being passed to each health check function.
• If the health check requires external external modules or other dependencies, the check should be implemented as a separate Go module(similarly how it is done for the tests, that require dependencies to other packages as well). This is required to avoid that when people import the base library, they also need to import all dependencies of all provided checks.
• The check should have a README.md in its root directory that describes how to use it and maybe what to look out for.
• You should provide a test that checks at least the happy path. If a docker container is required to properly test the check, the docker container can be added to the docker-compose.yaml file in the checks base package.

Should you have questions or require help, please join our discord chat room.

It should be possible to expose health checks as a prometheus gauge.

A few constraints to keep things clean and simple:

• The check should be added to the checks module that you can find in the development branch.
• As with all health check functions of this library, the check implementation should support accepting and forwarding context.Context that is being passed to each health check function.
• If the health check requires external external modules or other dependencies, the check should be implemented as a separate Go module(similarly how it is done for the tests, that require dependencies to other packages as well). This is required to avoid that when people import the base library, they also need to import all dependencies of all provided checks.
• The check should have a README.md in its root directory that describes how to use it and maybe what to look out for.
• You should provide a test that checks at least the happy path. If a docker container is required to properly test the check, the docker container can be added to the docker-compose.yaml file in the checks base package.

Should you have questions or require help, please join our discord chat room.