In the API of the Pyctuator object I did not find a way to secure the provided endpoints with BasicAuth. What would be the most straightforward way of doing this using FastAPI?

Also, how can i communicate the credentials to Spring Boot Admin?

If I understood https://codecentric.github.io/spring-boot-admin/current/#spring-boot-admin-client right, I can use something like:

    metadata={
        "user.name": "foo",
        "user.password": "bar"
    }

In the metadata arg of Pyctuator. Is that correct?

In our infrastructure we use custom elements of the info endpoint for among other things grafana links. Could you add a function for registering custom fields in the info endpoint?

Bumps uvicorn from 0.9.1 to 0.11.7.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

As the title says, could you provide a feature to customize the scrubbing behaviour OsEnvironmentVariableProvider / the scrub_secrets function? Even better: Is there a way to remove certain environment variables from the systemEnvironment dict alltogether?

Background: We are using Pyctuator in our CloudFoundry PaaS environment. CloudFoundry uses VCAP_SERVICES variables to provide service credentials via a JSON Blob. Of course, this cannot be scrubbed by the default implementation, so almost all of our sensible credentials are getting exposed via the Actuator Endpoints. We would prefer to just exclude VCAP_SERVICES from the exposed environment variables.

Hello, first I would like to congratulate all the maintainers for this relevant project.

I am adopting the actuator in all the languages ​​we use (node, python, .netCore and Java).

I missed an option to define the application's metadata for spring boot registration.

I made this simple proposal to support customized metadata.

I hope that this PR is worthy to be adopted.

I found a block to run the tests locally, I am trying hard to beat it.

To guarantee functionality, I tested it manually, either passing the new parameter or omitting it.

PR for #44

This PR enables the HttpTracer to run scrubbing function similar to the environment scrubber

During the implementation I noticed that the different vendors differ. Some contain a list of values for each headers, some can only have one.

This PR normalises the traces to always contains a list.

Also flask has capitalised headers e.g.: Authorization vs authorization

Currently I'm checking this in the E2E but you could thinking about normaling it as well

Hi,

I'm trying to install Pyctuator on our existing app on Flask/uWSGI.

Everything works fine except that pyctuator is modifying the logging configuration of the application, and some things don't work as expected after Pyctuator is set up.

Our app is created the following way (redacted to the relevant part only) :

def create_app():

    """ Flask application factory """

    # create and configure the app
    app = Flask(__name__, instance_path=instance_path, instance_relative_config=True)
    app.config.from_json('config.json')

    # Allow CORS from angers.cnp.fr
    CORS(app)

    # Add proxyfix middleware to handle redirects correctly
    # x_port = 0 to work around Kong sending incorrect X-Forwarded-Port header
    app.wsgi_app = ProxyFix(app.wsgi_app, x_host=1, x_port=0)

    # configure the DB
    # pool_recycle must be set below 3600 to avoid the session to be killed by the firewall
    engine = create_engine(app.config["DATABASE_URI"], convert_unicode=True, pool_pre_ping=True, pool_recycle=3500)

   # Enable pyctuator
    pyctuator = Pyctuator(
        app,
        "Plateforme IA",
        pyctuator_endpoint_url=app.config["ROOT_API_PATH"]+'/actuator',
        app_url=None,
        registration_url=None
    )


    pyctuator.set_build_info(
        name="Plateforme IA",
        version=app.config["VERSION"],
        time=dateutil.parser.parse(app.config["BUILD_DATE"]),
    )

    pyctuator.register_health_provider(DbHealthProvider(engine))

    sentinel = Sentinel(app.config["CACHE_REDIS_SENTINELS"], socket_timeout=1.0)
    master = sentinel.master_for(app.config["CACHE_REDIS_SENTINEL_MASTER"], socket_timeout=1.0)
    pyctuator.register_health_provider(RedisHealthProvider(master))

    return app

application = create_app()

• Before setting up Pyctuator, any runtime exception will be logged in uwsgi_error.log and I can use the root logger anywhere in an endpoint code and it gets logged in uwsgi_error.log, such as :

import logging
logging.critical("Test")

• After setting up Pyctuator, nothing is logged in uwsgi_error.log at all.

This is not acceptable for us.

Any idea why we have this behaviour ?

FYI if I comment the line 92 in pyctuator.py, the problem goes away :

      root_logger.addHandler(self.pyctuator_impl.logfile.log_messages)

Thanks

Added initial integration with aiohttp #17.

@MatanRubin would you rather I use the notation below to fix the pylint warning or is there any other?

• https://github.com/SolarEdgeTech/pyctuator/runs/828838499?check_suite_focus=true#step:12:11

# current code
async def get_info(request: web.Request) -> web.Response:
            return web.json_response(self._to_dict(pyctuator_impl.app_info))

# fix W0613: Unused argument 'request' (unused-argument)
async def get_info(_: web.Request) -> web.Response:
            return web.json_response(self._to_dict(pyctuator_impl.app_info))

I have the following minimal example:

from dataclasses import dataclass

from fastapi import FastAPI
from pyctuator.health.health_provider import HealthDetails, HealthProvider, HealthStatus, Status
from pyctuator.pyctuator import Pyctuator

@dataclass
class AppSpecificHealthDetails(HealthDetails):
    my_dependency_connectivity: str


class MyHealthProvider(HealthProvider):
    def is_supported(self) -> bool:
        return True

    def get_name(self) -> str:
        return "my-dependency-health"

    def get_health(self) -> HealthStatus:
        return HealthStatus(
            status=Status.DOWN,
            details=AppSpecificHealthDetails(my_dependency_connectivity="is down")
        )


app = FastAPI()


@app.get("/")
async def hello_world():
    return {"message": "hello world"}

pyctuator = Pyctuator(
    app,
    app_name="my_app",
    app_url="http://127.0.0.1:8000/",
    pyctuator_endpoint_url="http://127.0.0.1:8000/pyctuator",
    registration_url=None
)

pyctuator.register_health_provider(MyHealthProvider())

As expected the Status of the Subcomponent is DOWN, and subsequently the status of the whole application is also DOWN. However the status_code is still 200. I would expect to receive 503 for Status codes DOWN, just like in a Spring Boot Application.

$ curl -vs http://localhost:8000/pyctuator/health
{"status":"DOWN","details":{"my-dependency-health":{"status":"DOWN","details":{"my_dependency_connectivity":"is down"}}}}*   Trying 127.0.0.1:8000...
* Connected to localhost (127.0.0.1) port 8000 (#0)
> GET /pyctuator/health HTTP/1.1
> Host: localhost:8000
> User-Agent: curl/7.81.0
> Accept: */*
>
* Mark bundle as not supporting multiuse
< HTTP/1.1 200 OK
< date: Fri, 02 Sep 2022 08:51:27 GMT
< server: uvicorn
< content-length: 121
< content-type: application/vnd.spring-boot.actuator.v2+json;charset=UTF-8
<
{ [121 bytes data]
* Connection #0 to host localhost left intact

Not sure if I am the only one, but it seems like there is an issue getting the package:

ERROR: Could not find a version that satisfies the requirement pyctuator (from versions: none) ERROR: No matching distribution found for pyctuator root ➜ /workspaces/test-python $

There is currently no option to set the SSL context to use for registration requests. In my case this is required as my SBA server requires a valid certificate.

Looking at the code here it doesn't look like it would be too difficult to pass in an SSL context to use for this in a similar way to registration_auth.

Hi - it would be helpful to a project I am on to support Apache Cassandra. If someone could give me an overview or some documentation on how this might be best implemented I would be happy to develop it.

Thanks.

See https://docs.spring.io/spring-boot/docs/current/reference/html/production-ready-features.html#production-ready-kubernetes-probes for how its done in spring-boot's actuator.

In high level, pyctuator should support telling k8s when an application/service is ready to serve requests (i.e. readiness probe) and if the application is alive (this is the liveness probe) - this is different from the health status returned by /pyctuator/health for two reasons:

1. it should return fast, so shouldn't include health checks of external resources
2. it should reflect the k8s lifecycle as described in actuator's documentation (and in k8s docs of course)

While actuator allow to configure additional checks to these probes, it is suggested that initially we'll provide default implementation that users can choose to use.

So far Pyctuator's API was manually built to match the spring-boot-actuator API and therefore some deviation is expected (and accepted...).

Please identify these deviations and prioritize fixing them by comparing the API to https://docs.spring.io/spring-boot/docs/current/actuator-api/html/.

Even better, generate the API code (data classes for sure) from actuator's openapidoc. The openapidoc can be generated when running a spring-boot-admin application that's configured with actuator and with springdoc.show-actuator set to true - see example in the api-docs.zip.