Why my ETF Constituents Universe filter not called on daily basis

The ETFConstituentsFilter function is indeed expected to be called on a daily basis as per the documentation. However, in your code, you are returning Universe.Unchanged which means that the universe members remain the same as they were on the previous day. This could be the reason why you are not seeing the debug log message on a daily basis.

If you want to see the debug log message every day, you should return a list of symbols from the ETFConstituentsFilter function. For example, you can return all the constituents as follows:

def ETFConstituentsFilter(self, constituents: List[ETFConstituentData]) -> List[Symbol]:
    self.Debug(f"[INFO::Portfolio]: Starts ETF filter update ...")
    return [c.Symbol for c in constituents]

This will select all the constituents of the ETF for your universe and you should see the debug log message every day.

Please note that the ETFConstituentsFilter function is called asynchronously as you have set self.UniverseSettings.Asynchronous = True. This means that the function is called in parallel with your algorithm's main event loop, and the timing of the debug log messages may not align exactly with your algorithm's daily events.

Still I dont think its helping, I have the following code after modified, and I dont see any other calls to the filter except on day 1. Also, the OnSecuritiesChanged hook is never triggered as well (not a single log). Which I expect it to be triggered frequently as I am simply returning a random list which contains single random element from first couple constituents of the list.

from AlgorithmImports import * 
import random

class ETFConstituentsUniverseAlgorithm(QCAlgorithm):

    symbol_data_by_symbol = {}

    def Initialize(self):
        self.SetCash(100000)
        self.SetStartDate(2020, 1, 1)
        self.SetEndDate(2020, 2, 28)

        self.UniverseSettings.Resolution = Resolution.Daily
        self.AddUniverse(self.Universe.ETF("SPY", Market.USA), self.ETFConstituentsFilter)

    def ETFConstituentsFilter(self, constituents: List[ETFConstituentData]) -> List[Symbol]:
        self.Debug(f"[INFO::Portfolio]: Starts ETF filter update ...")
        cnt, target = 0, random.randint(1, 10) 
        ret = []
        for c in constituents:
            if c == target:
                ret.append(c.Symbol)
                break;
            cnt += 1

        return ret

    def OnSecuritiesChanged(self, changes: SecurityChanges) -> None:
        for security in changes.AddedSecurities:
            self.Debug(f"{self.Time}: Added {security.Symbol}")
    
        for security in changes.RemovedSecurities:
            self.Debug(f"{self.Time}: Removed {security.Symbol}")

The ETFConstituentsFilter function is indeed expected to be called on a daily basis. However, the OnSecuritiesChanged method is only called when there are changes to the securities in your universe. In your case, you are selecting a random constituent from the first 10 constituents of the ETF. If the selected constituent is the same as the one selected on the previous day, then OnSecuritiesChanged will not be called because there are no changes to the securities in your universe.

If you want to see the OnSecuritiesChanged method being called more frequently, you could modify your ETFConstituentsFilter function to select a different constituent each day. For example, you could select a constituent based on the current day of the month:

def ETFConstituentsFilter(self, constituents: List[ETFConstituentData]) -> List[Symbol]:
    self.Debug(f"[INFO::Portfolio]: Starts ETF filter update ...")
    index = self.Time.day % 10  # Select a different constituent each day
    return [constituents[index].Symbol]

This will select a different constituent from the first 10 constituents each day, which should result in the OnSecuritiesChanged method being called more frequently.

Please note that the ETFConstituentsFilter function is called asynchronously as you have set self.UniverseSettings.Asynchronous = True. This means that the function is called in parallel with your algorithm's main event loop, and the timing of the debug log messages may not align exactly with your algorithm's daily events.